@skyhook-io/k8s-ui 1.14.3 → 1.14.5

package/src/components/topology/K8sResourceNode.tsx

@@ -168,6 +168,34 @@ function getIssueTooltip(issue: string | undefined): React.ReactNode {
   );
 }
 
+// Full port list for the Service subtitle's hover affordance — the subtitle
+// itself only ever shows the first port + a count, so this is the only place
+// a multi-port Service's other ports are visible without opening the detail
+// page. Formatting (hide targetPort when it matches port) mirrors
+// ServicePortCards in ServiceRenderer.tsx so a Service's ports read the same
+// whether glanced at in the graph or opened in the full resource view.
+function servicePortsTooltip(ports: ServicePortEntry[]): React.ReactNode | null {
+  if (ports.length < 2) return null;
+  return (
+    <div className="max-w-xs space-y-0.5">
+      {ports.map((p, i) => {
+        const target =
+          p.targetPort != null && p.targetPort !== String(p.port)
+            ? ` → ${p.targetPort}`
+            : "";
+        const proto = p.appProtocol || p.protocol;
+        return (
+          <div key={i} className="text-[11px]">
+            {p.name && <span className="text-theme-text-tertiary">{p.name} </span>}
+            <span className="font-medium">{p.port}{target}</span>
+            {proto && <span className="text-theme-text-tertiary"> ({proto})</span>}
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
 // Default dimensions for unknown CRD kinds
 export const DEFAULT_NODE_DIMENSIONS = { width: 260, height: 84 };
 
@@ -322,6 +350,16 @@ const SUMMARY_POD_KINDS = new Set<NodeKind>([
   "Service",
 ]);
 
+// Shape of one entry in a Service node's nodeData.ports (pkg/topology/builder.go's
+// serviceTopologyPorts). name/appProtocol are omitted server-side when unset.
+export interface ServicePortEntry {
+  name?: string;
+  port: number;
+  targetPort?: string;
+  protocol?: string;
+  appProtocol?: string;
+}
+
 export function baseSubtitle(kind: NodeKind, nodeData: Record<string, unknown>): string {
   if (nodeData.deploymentMembership === 'source-only') {
     return `Declared by ${nodeData.deploymentSourceLabel ?? 'deployment source'}`
@@ -369,8 +407,10 @@ export function baseSubtitle(kind: NodeKind, nodeData: Record<string, unknown>):
       return (nodeData.phase as string) || "Unknown";
     case "Service": {
       const svcType = (nodeData.type as string) || "ClusterIP";
-      const port = nodeData.port;
-      return port ? `${svcType} :${port}` : svcType;
+      const ports = (nodeData.ports as ServicePortEntry[] | undefined) || [];
+      if (ports.length === 0) return svcType;
+      const more = ports.length > 1 ? ` +${ports.length - 1} more` : "";
+      return `${svcType} :${ports[0].port}${more}`;
     }
     case "CalicoNetworkPolicy":
     case "CalicoGlobalNetworkPolicy":
@@ -513,6 +553,9 @@ export const K8sResourceNode = memo(function K8sResourceNode({
   const { ownerColorIndex } = ownershipOf(nodeData)
   const hue = ownerColorIndex !== null ? workloadHue(ownerColorIndex) : undefined
   const subtitle = getSubtitle(kind, nodeData)
+  const portsTooltip = kind === 'Service'
+    ? servicePortsTooltip((nodeData.ports as ServicePortEntry[] | undefined) || [])
+    : null
   const isInternet = kind === 'Internet'
   const isPodGroup = kind === 'PodGroup'
   const isSmallNode = kind === 'ConfigMap' || kind === 'Secret' || kind === 'ServiceAccount' || kind === 'SealedSecret' || kind === 'ServiceMonitor' || kind === 'PodMonitor' || kind === 'HorizontalPodAutoscaler'
@@ -730,9 +773,17 @@ export const K8sResourceNode = memo(function K8sResourceNode({
 
           {/* Subtitle */}
           {subtitle && (
-            <div className="text-xs text-theme-text-secondary truncate mt-0.5">
-              {subtitle}
-            </div>
+            portsTooltip ? (
+              <Tooltip content={portsTooltip} position="bottom" wrapperClassName="max-w-full mt-0.5">
+                <div className="text-xs text-theme-text-secondary truncate cursor-help">
+                  {subtitle}
+                </div>
+              </Tooltip>
+            ) : (
+              <div className="text-xs text-theme-text-secondary truncate mt-0.5">
+                {subtitle}
+              </div>
+            )
           )}
         </div>
       </div>

package/src/components/topology/TopologyGraph.tsx

@@ -245,6 +245,23 @@ interface TopologyGraphProps {
   children?: ReactNode
 }
 
+// A pod group's children normally carry the health the server computed. Without
+// it, the phase is honest for every state except Running: a crash-looping pod
+// sits at Phase=Running with its container restarting, so that one case says
+// unknown rather than repeating the bug this fallback exists behind.
+export function phaseOnlyHealth(phase: string | undefined): HealthStatus {
+  switch (phase) {
+    case 'Failed':
+      return 'unhealthy'
+    case 'Pending':
+      return 'degraded'
+    case 'Succeeded':
+      return 'neutral'
+    default:
+      return 'unknown'
+  }
+}
+
 export function TopologyGraph({
   topology,
   viewMode,
@@ -430,7 +447,7 @@ export function TopologyGraph({
         // the kubelet's Waiting->Running oscillation, which the phase alone
         // hides — a crash-looping pod sits at Phase=Running. Deriving it here
         // again would rebuild that logic in a second place and get it wrong.
-        status: pod.status ?? 'unknown',
+        status: pod.status ?? phaseOnlyHealth(pod.phase),
         data: {
           ...podGroupNode.data,
           namespace: pod.namespace,

package/src/components/topology/pod-phase-fallback.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest'
+import { phaseOnlyHealth } from './TopologyGraph'
+
+// Only reached when the server sent no per-pod status — an older Radar behind a
+// newer embedding host. The point of the fallback is that it must not repeat the
+// bug it stands in for.
+describe('phaseOnlyHealth', () => {
+  it('does not call a Running pod healthy', () => {
+    // A crash-looping pod sits at Phase=Running with its container restarting,
+    // so Running is the one phase that hides a fault.
+    expect(phaseOnlyHealth('Running')).toBe('unknown')
+  })
+
+  it('reads the phases that are honest on their own', () => {
+    expect(phaseOnlyHealth('Failed')).toBe('unhealthy')
+    expect(phaseOnlyHealth('Pending')).toBe('degraded')
+    expect(phaseOnlyHealth('Succeeded')).toBe('neutral')
+  })
+
+  it('says nothing for a phase it does not recognise', () => {
+    expect(phaseOnlyHealth(undefined)).toBe('unknown')
+    expect(phaseOnlyHealth('SomeFuturePhase')).toBe('unknown')
+  })
+})

package/src/components/ui/Badge.tsx

@@ -23,7 +23,10 @@ export type BadgeSize = 'sm' | 'default'
 //   "tell these sibling options apart". The only place sharing is intended.
 // - structural: ports/paths/hosts/weights/names — neutral data fragments, not a
 //   status. Its own name so it can diverge from severity-neutral later.
-export type BadgeTone = 'note' | 'accent1' | 'accent2' | 'accent3' | 'structural'
+// - agent:    words an AI agent attached to a Radar fact (evidence roles such
+//   as "Cause" / "Rules out"). Muted brand accent on purpose: never a severity
+//   hue, so an agent's framing can never be mistaken for a Radar finding.
+export type BadgeTone = 'note' | 'accent1' | 'accent2' | 'accent3' | 'structural' | 'agent'
 
 interface BadgeProps {
   /** Severity-based coloring (status badges) */
@@ -231,6 +234,7 @@ const TONE: Record<BadgeTone, string> = {
   accent3:    'bg-teal-100 text-teal-800 border-teal-300 dark:bg-teal-950/50 dark:text-teal-400 dark:border-teal-700/40',
   // neutral data fragment (ports/paths/hosts/names)
   structural: 'bg-theme-elevated text-theme-text-secondary border-theme-border',
+  agent:      'bg-accent-muted text-accent-text border-accent/30',
 }
 
 // Structure classes

package/src/components/ui/index.ts

@@ -33,6 +33,11 @@ export { InClusterConsentDialog } from './InClusterConsentDialog'
 export { ToastProvider, useToast, showApiError, showApiSuccess } from './Toast'
 export { CodeViewer } from './CodeViewer'
 export { YamlEditor, YamlDiffEditor } from './YamlEditor'
+// Boots the self-hosted Monaco runtime (bundled editor, local workers) without
+// pulling monaco-editor into the main bundle. Anything that mounts a bare
+// `Editor` must await this first, or @monaco-editor/react reaches for its CDN.
+export const ensureMonacoRuntime = () =>
+  import('./monacoRuntime').then(({ ensureMonaco }) => ensureMonaco())
 export type {
   YamlDiagnostic,
   YamlDocumentIdentity,

package/src/components/ui/monacoRuntime.ts

@@ -2,7 +2,21 @@
 
 import { loader } from '@monaco-editor/react'
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api'
+// Tokenizers only — the set the YAML editor and the pod file viewer hand to
+// Monaco. JSON deliberately absent: its language lives in vs/language/json and
+// spawns a validation worker this runtime does not ship; viewers highlight
+// JSON with the YAML tokenizer, which covers it.
 import 'monaco-editor/esm/vs/basic-languages/yaml/yaml.contribution'
+import 'monaco-editor/esm/vs/basic-languages/xml/xml.contribution'
+import 'monaco-editor/esm/vs/basic-languages/html/html.contribution'
+import 'monaco-editor/esm/vs/basic-languages/css/css.contribution'
+import 'monaco-editor/esm/vs/basic-languages/javascript/javascript.contribution'
+import 'monaco-editor/esm/vs/basic-languages/typescript/typescript.contribution'
+import 'monaco-editor/esm/vs/basic-languages/python/python.contribution'
+import 'monaco-editor/esm/vs/basic-languages/shell/shell.contribution'
+import 'monaco-editor/esm/vs/basic-languages/markdown/markdown.contribution'
+import 'monaco-editor/esm/vs/basic-languages/ini/ini.contribution'
+import 'monaco-editor/esm/vs/basic-languages/dockerfile/dockerfile.contribution'
 import 'monaco-editor/esm/vs/editor/contrib/find/browser/findController.js'
 import 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding.js'
 import 'monaco-editor/esm/vs/editor/contrib/format/browser/formatActions.js'

package/src/monaco-deep.d.ts

@@ -3,3 +3,13 @@ declare module 'monaco-editor/esm/vs/editor/editor.api' {
 }
 
 declare module 'monaco-editor/esm/vs/basic-languages/yaml/yaml.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/xml/xml.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/html/html.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/css/css.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/javascript/javascript.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/typescript/typescript.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/python/python.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/shell/shell.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/markdown/markdown.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/ini/ini.contribution'
+declare module 'monaco-editor/esm/vs/basic-languages/dockerfile/dockerfile.contribution'

package/src/theme/components.css

@@ -228,6 +228,35 @@
     border-color: transparent;
   }
 
+  /* Colour-named accents carry no health meaning — they exist so an
+     informational badge can pick a hue without borrowing a status semantic.
+     A categorical badge (an admission verb, a policy action, a configured
+     mode) belongs here; only evidence about a resource's condition belongs on
+     .status-healthy / -degraded / -unhealthy. */
+  .status-green {
+    background-color: light-dark(rgba(34, 197, 94, 0.15), rgba(34, 197, 94, 0.2));
+    color: light-dark(#15803d, #4ade80);
+    border-color: transparent;
+  }
+
+  .status-red {
+    background-color: light-dark(rgba(239, 68, 68, 0.15), rgba(239, 68, 68, 0.2));
+    color: light-dark(#b91c1c, #f87171);
+    border-color: transparent;
+  }
+
+  .status-amber {
+    background-color: light-dark(rgba(234, 179, 8, 0.15), rgba(234, 179, 8, 0.2));
+    color: light-dark(#a16207, #facc15);
+    border-color: transparent;
+  }
+
+  .status-blue {
+    background-color: light-dark(rgba(59, 130, 246, 0.15), rgba(59, 130, 246, 0.2));
+    color: light-dark(#2563eb, #60a5fa);
+    border-color: transparent;
+  }
+
   .status-cyan {
     background-color: light-dark(rgba(6, 182, 212, 0.15), rgba(6, 182, 212, 0.2));
     color: light-dark(#0891b2, #22d3ee);

package/src/types/core.ts

@@ -516,6 +516,9 @@ export interface ContextInfo {
   /** Source kubeconfig label (e.g. "kube-cluster-paris"). Set by the backend
    *  for contexts loaded through the isolated source registry. */
   source?: string
+  /** AWS profile extracted from the exec plugin's --profile arg or AWS_PROFILE
+   *  env var. Present only for EKS contexts that pin a profile. */
+  awsProfile?: string
 }
 
 // Namespace
@@ -683,24 +686,34 @@ export type HPADiagnosisState =
   | 'stabilized'
   | 'unknown'
 
-export interface HPADiagnosis {
+export interface HPABounds {
+  min: number
+  max: number
+  current: number
+  desired: number
+  observedGeneration?: number
+  generation?: number
+}
+
+// The subset of an HPA diagnosis that HPADiagnosisSummary presents. Producers
+// that carry a richer or looser envelope (Radar's own HPADiagnosis, the
+// investigation evidence projection) extend this so the presentation rules —
+// state severity, state label, reason redundancy — cannot drift per surface.
+export interface HPADiagnosisView {
   state: HPADiagnosisState
   summary: string
+  bounds?: HPABounds
+  reasons?: HPAReasonSummary[]
+}
+
+export interface HPADiagnosis extends HPADiagnosisView {
   target: {
     apiVersion?: string
     kind?: string
     name?: string
   }
-  bounds: {
-    min: number
-    max: number
-    current: number
-    desired: number
-    observedGeneration?: number
-    generation?: number
-  }
+  bounds: HPABounds
   metrics?: HPAMetricSummary[]
-  reasons?: HPAReasonSummary[]
 }
 
 export interface HPAReasonSummary {

package/src/utils/badge-colors.ts

@@ -74,7 +74,7 @@ export const NODEPOOL_MODE_BADGE: Record<string, string> = {
 
 // Translucent gray badge for "inactive / unknown / pending / unset / disabled" states.
 // The de-facto fallback in renderers when no severity or category applies.
-export const BADGE_INACTIVE = 'bg-gray-500/20 text-gray-400'
+export const BADGE_INACTIVE = 'status-unknown'
 
 // Best practices category colors
 export const BP_CATEGORY_BADGE: Record<string, string> = {

package/src/utils/index.ts

@@ -7,6 +7,7 @@ export * from './navigation'
 export * from './context-name'
 export * from './animation'
 export * from './resource-hierarchy'
+export * from './log-export'
 export * from './log-format'
 export * from './download'
 export * from './clipboard'

package/src/utils/log-export.test.ts

@@ -0,0 +1,225 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  LOG_EXPORT_FORMATS,
+  previewLogExport,
+  serializeLogEntries,
+  type ExportableLogEntry,
+  type LogExportFormat,
+} from './log-export'
+
+const ESC = '\u001b'
+
+const entry = (over: Partial<ExportableLogEntry> = {}): ExportableLogEntry => ({
+  timestamp: '2024-01-20T10:30:00.123456789Z',
+  content: 'connection refused',
+  container: 'app',
+  pod: 'api-7d9f',
+  ...over,
+})
+
+const opts = (over: Partial<{ format: LogExportFormat; showTimestamps: boolean; showPodName: boolean }> = {}) => ({
+  format: 'txt' as LogExportFormat,
+  showTimestamps: true,
+  showPodName: true,
+  ...over,
+})
+
+describe('serializeLogEntries — text', () => {
+  it('emits the raw RFC3339 timestamp rather than any display format', () => {
+    const { content } = serializeLogEntries([entry()], opts({ showPodName: false }))
+    expect(content).toBe('2024-01-20T10:30:00.123456789Z connection refused')
+  })
+
+  it('omits timestamps when the viewer has them hidden', () => {
+    const { content } = serializeLogEntries([entry()], opts({ showTimestamps: false, showPodName: false }))
+    expect(content).toBe('connection refused')
+  })
+
+  it('attributes pod and container when pod names are shown', () => {
+    const { content } = serializeLogEntries([entry()], opts({ showTimestamps: false }))
+    expect(content).toBe('[api-7d9f/app] connection refused')
+  })
+
+  it('falls back to the pod alone when no container is known', () => {
+    const { content } = serializeLogEntries([entry({ container: undefined })], opts({ showTimestamps: false }))
+    expect(content).toBe('[api-7d9f] connection refused')
+  })
+
+  it('drops pod attribution for entries with no pod, even when the toggle is on', () => {
+    const { content } = serializeLogEntries([entry({ pod: undefined })], opts({ showTimestamps: false }))
+    expect(content).toBe('connection refused')
+  })
+
+  it('skips an empty timestamp instead of emitting a leading space', () => {
+    const { content } = serializeLogEntries([entry({ timestamp: '' })], opts({ showPodName: false }))
+    expect(content).toBe('connection refused')
+  })
+
+  it('strips ANSI escapes', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: `${ESC}[31mconnection refused${ESC}[0m` })],
+      opts({ showTimestamps: false, showPodName: false }),
+    )
+    expect(content).toBe('connection refused')
+  })
+
+  it('preserves raw JSON content rather than any collapsed rendering', () => {
+    const json = '{"level":"error","msg":"connection refused","stack":"a\\nb"}'
+    const { content } = serializeLogEntries([entry({ content: json })], opts({ showTimestamps: false, showPodName: false }))
+    expect(content).toBe(json)
+  })
+
+  it('joins entries with newlines and returns empty for no entries', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: 'first' }), entry({ content: 'second' })],
+      opts({ showTimestamps: false, showPodName: false }),
+    )
+    expect(content).toBe('first\nsecond')
+    expect(serializeLogEntries([], opts()).content).toBe('')
+  })
+})
+
+describe('serializeLogEntries — structured formats', () => {
+  it('keeps the timestamp field in JSON even when the display toggle is off', () => {
+    const { content, mime, extension } = serializeLogEntries(
+      [entry()],
+      opts({ format: 'json', showTimestamps: false }),
+    )
+    expect(JSON.parse(content)).toEqual([{
+      timestamp: '2024-01-20T10:30:00.123456789Z',
+      pod: 'api-7d9f',
+      container: 'app',
+      content: 'connection refused',
+    }])
+    expect(mime).toBe('application/json;charset=utf-8')
+    expect(extension).toBe('json')
+  })
+
+  it('keeps the pod key in JSON even when pod attribution is off, since the display toggle is not a schema', () => {
+    const { content } = serializeLogEntries([entry()], opts({ format: 'json', showPodName: false }))
+    expect(Object.keys(JSON.parse(content)[0])).toEqual(['timestamp', 'pod', 'container', 'content'])
+  })
+
+  it('omits the pod key only for entries that genuinely have no pod', () => {
+    const { content } = serializeLogEntries([entry({ pod: undefined })], opts({ format: 'json' }))
+    expect(Object.keys(JSON.parse(content)[0])).toEqual(['timestamp', 'container', 'content'])
+  })
+
+  it('strips ANSI from structured content too', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: `${ESC}[31mboom${ESC}[0m` })],
+      opts({ format: 'json' }),
+    )
+    expect(JSON.parse(content)[0].content).toBe('boom')
+  })
+
+  it('writes a CSV header matching the columns it emits', () => {
+    const { content, mime } = serializeLogEntries([entry()], opts({ format: 'csv' }))
+    expect(content.split('\n')).toEqual([
+      'timestamp,pod,container,content',
+      '"2024-01-20T10:30:00.123456789Z","api-7d9f","app","connection refused"',
+    ])
+    expect(mime).toBe('text/csv;charset=utf-8')
+  })
+
+  it('keeps the CSV pod column when pod attribution is off but the data has pods', () => {
+    const { content } = serializeLogEntries([entry()], opts({ format: 'csv', showPodName: false }))
+    expect(content.split('\n')[0]).toBe('timestamp,pod,container,content')
+  })
+
+  it('drops the CSV pod column only when no entry has a pod', () => {
+    const { content } = serializeLogEntries([entry({ pod: undefined })], opts({ format: 'csv' }))
+    expect(content.split('\n')).toEqual([
+      'timestamp,container,content',
+      '"2024-01-20T10:30:00.123456789Z","app","connection refused"',
+    ])
+  })
+
+  it('keeps the column count aligned when only some entries carry a pod', () => {
+    const { content } = serializeLogEntries(
+      [entry({ pod: undefined }), entry()],
+      opts({ format: 'csv' }),
+    )
+    const [header, ...rows] = content.split('\n')
+    expect(header.split(',').length).toBe(4)
+    for (const row of rows) expect(row.split('","').length).toBe(4)
+  })
+
+  it('neutralizes cells a spreadsheet would evaluate as a formula', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: '=cmd|\' /c calc\'!A1' }), entry({ content: '+1' }), entry({ content: '-rf /' }), entry({ content: '@SUM(A1)' })],
+      opts({ format: 'csv', showPodName: false }),
+    )
+    const cells = content.split('\n').slice(1).map(r => r.split(',').pop())
+    expect(cells).toEqual([
+      '"\'=cmd|\' /c calc\'!A1"',
+      '"\'+1"',
+      '"\'-rf /"',
+      '"\'@SUM(A1)"',
+    ])
+  })
+
+  it('leaves ordinary content unprefixed', () => {
+    const { content } = serializeLogEntries([entry()], opts({ format: 'csv', showPodName: false }))
+    expect(content).toContain('"connection refused"')
+  })
+
+  it('doubles quotes inside a CSV cell', () => {
+    const { content } = serializeLogEntries(
+      [entry({ content: 'said "hello"', pod: undefined })],
+      opts({ format: 'csv' }),
+    )
+    expect(content.split('\n')[1]).toBe('"2024-01-20T10:30:00.123456789Z","app","said ""hello"""')
+  })
+
+  it('emits a header-only CSV and an empty JSON array for no entries', () => {
+    expect(serializeLogEntries([], opts({ format: 'csv' })).content).toBe('timestamp,container,content')
+    expect(serializeLogEntries([], opts({ format: 'json' })).content).toBe('[]')
+  })
+
+  it('declares a charset so non-ASCII content survives a spreadsheet import', () => {
+    for (const format of LOG_EXPORT_FORMATS) {
+      expect(serializeLogEntries([], opts({ format })).mime).toContain('charset=utf-8')
+    }
+  })
+})
+
+describe('previewLogExport', () => {
+  it('shows the first two lines of a text export', () => {
+    expect(previewLogExport(
+      [entry({ content: 'first' }), entry({ content: 'second' }), entry({ content: 'third' })],
+      opts({ showTimestamps: false, showPodName: false }),
+    )).toEqual(['first', 'second'])
+  })
+
+  it('shows one compact object for JSON, not the pretty-printed array', () => {
+    const [line, ...rest] = previewLogExport([entry()], opts({ format: 'json' }))
+    expect(rest).toEqual([])
+    expect(line).toBe('{"timestamp":"2024-01-20T10:30:00.123456789Z","pod":"api-7d9f","container":"app","content":"connection refused"}')
+  })
+
+  it('shows the CSV header alongside a row so the columns are legible', () => {
+    expect(previewLogExport([entry()], opts({ format: 'csv' }))).toEqual([
+      'timestamp,pod,container,content',
+      '"2024-01-20T10:30:00.123456789Z","api-7d9f","app","connection refused"',
+    ])
+  })
+
+  it('previews exactly what the payload contains', () => {
+    for (const format of ['txt', 'json', 'csv'] as LogExportFormat[]) {
+      const o = opts({ format })
+      const preview = previewLogExport([entry()], o)
+      const { content } = serializeLogEntries([entry()], o)
+      for (const line of preview) {
+        // JSON pretty-prints across lines, so compare on the field values instead.
+        if (format === 'json') expect(JSON.parse(content)[0]).toEqual(JSON.parse(line))
+        else expect(content.split('\n')).toContain(line)
+      }
+    }
+  })
+
+  it('returns nothing when there is nothing to export', () => {
+    expect(previewLogExport([], opts())).toEqual([])
+  })
+})