@skyhook-io/radar-app 1.16.3 → 1.17.0

package/src/components/traffic/trafficFilters.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import type { AggregatedFlow, TrafficFlow } from '../../types'
-import { matchesStatusRanges, bucketsFromCounts, bucketsFromStatus, isRateBasedSource, keepAvailable, effectiveThreshold, volumeUnit, isExternalKind, isPolicyDropReason, requestRateOf, errorRateOf, formatRate, displayVolume, mergeFlowVolume, dedupeHTTPPairs, coverageLabel, latencyWeightOf } from './trafficFilters'
+import { matchesStatusRanges, bucketsFromCounts, bucketsFromStatus, isRateBasedSource, keepAvailable, effectiveThreshold, volumeUnit, isExternalKind, isPolicyDropReason, requestRateOf, errorRateOf, formatRate, displayVolume, mergeFlowVolume, dedupeHTTPPairs, coverageLabel, latencyWeightOf, endpointPair, selectionRawPairs, mergeRawPairs, graphEndpoint, graphSize, parseFocus, focusParam, focusId, touchesFocus, focusNeighborhood, endpointSummaries, searchEndpoints, namespaceSummaries, namespaceOverBudget, hasStatusData, connectionRows, selectionMatch, edgeCarriesPort, edgesOnPort, mergedEdgePort, selectedEdgeMatcher, type GraphFlow } from './trafficFilters'
 
 describe('matchesStatusRanges', () => {
   it('does not filter when nothing is selected', () => {
@@ -281,3 +281,400 @@ describe('coverageLabel', () => {
     expect(coverageLabel(undefined, '2026-09-30T08:39:04Z')).toBeNull()
   })
 })
+
+describe('selectionRawPairs', () => {
+  const edge = (src: [string, string, string], dst: [string, string, string]): AggregatedFlow => ({
+    source: { namespace: src[0], name: src[1], kind: src[2] },
+    destination: { namespace: dst[0], name: dst[1], kind: dst[2] },
+    protocol: 'tcp', port: 443, flowCount: 1, bytesSent: 0, bytesRecv: 0, connections: 1, lastSeen: '',
+  })
+  const a = edge(['shop', 'web-1', 'Pod'], ['', '52.1.1.1', 'External'])
+  const b = edge(['shop', 'web-1', 'Pod'], ['', '52.1.1.2', 'External'])
+  const c = edge(['shop', 'web-1', 'Pod'], ['shop', 'db-0', 'Pod'])
+  // The graph merged a and b into one edge to a renamed external service.
+  const merged: GraphFlow = {
+    ...a,
+    destination: { namespace: '', name: 'HTTPS', kind: 'External' },
+    rawPairs: [endpointPair(a), endpointPair(b)],
+  }
+  const plain: GraphFlow = { ...c, rawPairs: [endpointPair(c)] }
+
+  it('traces a renamed node back to every server edge merged into it', () => {
+    const pairs = selectionRawPairs([merged, plain], { type: 'node', nodeId: 'HTTPS' })
+    expect(pairs?.map(p => p.destination.name).sort()).toEqual(['52.1.1.1', '52.1.1.2'])
+  })
+
+  it('selects an edge by direction', () => {
+    expect(selectionRawPairs([merged, plain], { type: 'edge', sourceId: 'shop/web-1', destId: 'shop/db-0' }))
+      .toEqual([endpointPair(c)])
+    expect(selectionRawPairs([merged, plain], { type: 'edge', sourceId: 'shop/db-0', destId: 'shop/web-1' })).toBeNull()
+  })
+
+  it('dedupes server edges reached through several graph edges', () => {
+    const pairs = selectionRawPairs([merged, plain, { ...plain }], { type: 'node', nodeId: 'shop/web-1' })
+    expect(pairs).toHaveLength(3)
+  })
+
+  it('returns null when nothing traces back, so the list falls back to the sample', () => {
+    expect(selectionRawPairs([merged], { type: 'node', nodeId: 'addon-group' })).toBeNull()
+    expect(selectionRawPairs([merged], null)).toBeNull()
+  })
+
+  it('selects an edge on its own port: the graph draws one edge per port', () => {
+    const http = { ...c, port: 80 }
+    const graph: GraphFlow[] = [{ ...c, rawPairs: [endpointPair(c)] }, { ...http, rawPairs: [endpointPair(http)] }]
+    expect(selectionRawPairs(graph, { type: 'edge', sourceId: 'shop/web-1', destId: 'shop/db-0', port: 80 }))
+      .toEqual([endpointPair(http)])
+    expect(endpointPair(http).port).toBe(80)
+  })
+
+  it('keeps a merged edge selected whichever of its ports it happens to carry', () => {
+    const http = { ...c, port: 80 }
+    // Merged from :443 and :80; the merged edge kept :443 this refresh.
+    const mergedEdge: GraphFlow = { ...c, rawPairs: [endpointPair(c), endpointPair(http)] }
+    expect(selectionRawPairs([mergedEdge], { type: 'edge', sourceId: 'shop/web-1', destId: 'shop/db-0', port: 80 }))
+      .toHaveLength(2)
+  })
+
+  it('resolves the addon group, drawn as one node, through its virtual endpoints', () => {
+    const virtual: GraphFlow = {
+      ...a,
+      source: { namespace: '', name: 'addon-internet', kind: 'AddonInternet' },
+      destination: { namespace: '', name: 'addon-group-target', kind: 'AddonGroupTarget' },
+      port: 0,
+      rawPairs: [endpointPair(a)],
+    }
+    expect(selectionRawPairs([virtual], { type: 'edge', sourceId: 'addon-internet', destId: 'addon-group', port: 0 }))
+      .toEqual([endpointPair(a)])
+    expect(selectionRawPairs([virtual], { type: 'node', nodeId: 'addon-group' })).toEqual([endpointPair(a)])
+  })
+
+  it('keeps an edge apart from its unknown-direction twin', () => {
+    const twin = { ...c, directionUnknown: true }
+    const graph: GraphFlow[] = [{ ...c, rawPairs: [endpointPair(c)] }, { ...twin, rawPairs: [endpointPair(twin)] }]
+    expect(selectionRawPairs(graph, { type: 'edge', sourceId: 'shop/web-1', destId: 'shop/db-0', port: 443 }))
+      .toEqual([endpointPair(c)])
+    expect(selectionRawPairs(graph, { type: 'edge', sourceId: 'shop/web-1', destId: 'shop/db-0', port: 443, directionUnknown: true }))
+      .toEqual([endpointPair(twin)])
+  })
+
+  it('returns the same order however the server ordered its aggregation', () => {
+    const sel = { type: 'node' as const, nodeId: 'shop/web-1' }
+    expect(selectionRawPairs([plain, merged], sel)).toEqual(selectionRawPairs([merged, plain], sel))
+  })
+
+  it('selects the traffic of every addon inside the group while addons are grouped', () => {
+    const dns = edge(['kube-system', 'coredns', 'Pod'], ['shop', 'web-1', 'Pod'])
+    const graph: GraphFlow[] = [{ ...dns, rawPairs: [endpointPair(dns)] }, plain]
+    const inGroup = (e: { name: string }) => e.name === 'coredns'
+    expect(selectionRawPairs(graph, { type: 'node', nodeId: 'addon-group' }, inGroup)).toEqual([endpointPair(dns)])
+    expect(selectionRawPairs(graph, { type: 'node', nodeId: 'addon-group' })).toBeNull()
+  })
+
+  it('merges pairs in place', () => {
+    const into: GraphFlow = { ...a, rawPairs: [endpointPair(a)] }
+    const owned = into.rawPairs
+    mergeRawPairs(into, { ...b, rawPairs: [endpointPair(b)] })
+    expect(into.rawPairs).toBe(owned)
+    expect(into.rawPairs).toHaveLength(2)
+  })
+
+  it('omits an empty namespace so the server reads it as cluster-level', () => {
+    expect(endpointPair(a).destination).toEqual({ namespace: undefined, name: '52.1.1.1', kind: 'External' })
+  })
+})
+
+describe('graphEndpoint', () => {
+  it('names a pod with a known workload by the workload, like the server aggregation', () => {
+    expect(graphEndpoint({ namespace: 'shop', name: 'web-7d9f-x2k4q', kind: 'Pod', workload: 'web', workloadKind: 'Deployment' }))
+      .toEqual({ namespace: 'shop', name: 'web' })
+  })
+  it('leaves everything else as it is', () => {
+    const bare = { namespace: 'shop', name: 'debug', kind: 'Pod' }
+    expect(graphEndpoint(bare)).toBe(bare)
+    const ext = { namespace: '', name: 'world', kind: 'External', workload: 'x' }
+    expect(graphEndpoint(ext)).toBe(ext)
+  })
+})
+
+describe('graphSize', () => {
+  it('counts distinct nodes and weighs edges double', () => {
+    const f = (s: string, d: string): AggregatedFlow => ({
+      source: { namespace: 'a', name: s, kind: 'Workload' },
+      destination: { namespace: 'a', name: d, kind: 'Workload' },
+      protocol: 'tcp', port: 80, flowCount: 1, bytesSent: 0, bytesRecv: 0, connections: 1, lastSeen: '',
+    })
+    expect(graphSize([f('web', 'db'), f('web', 'cache'), f('api', 'db')])).toEqual({ nodes: 4, edges: 3, score: 10 })
+  })
+})
+
+function edge(src: string, dst: string, extra: Partial<AggregatedFlow> = {}): AggregatedFlow {
+  const ep = (id: string) => {
+    const [namespace, name] = id.includes('/') ? id.split('/') : ['', id]
+    return { namespace, name, kind: namespace ? 'Workload' : 'External' }
+  }
+  return {
+    source: ep(src), destination: ep(dst), protocol: 'tcp', port: 80,
+    flowCount: 1, bytesSent: 0, bytesRecv: 0, connections: 1, lastSeen: '', ...extra,
+  }
+}
+
+describe('focus', () => {
+  it('round-trips through the URL value', () => {
+    for (const focus of [{ namespace: 'shop', name: 'checkout' }, { name: 'api.stripe.com' }, { name: '10.0.0.0/8' }]) {
+      expect(parseFocus(focusParam(focus))).toEqual(focus)
+    }
+    expect(focusId(parseFocus('shop/checkout')!)).toBe('shop/checkout')
+    expect(focusId({ name: '10.0.0.0/8' })).toBe('10.0.0.0/8')
+    expect(parseFocus('shop/')).toBeNull()
+    expect(parseFocus('checkout')).toBeNull()
+    expect(parseFocus(null)).toBeNull()
+  })
+
+  it('keeps the edges at either end of the focus and nothing else', () => {
+    const flows = [edge('shop/web', 'shop/checkout'), edge('shop/checkout', 'pay/api'), edge('shop/web', 'shop/cart')]
+    const n = focusNeighborhood(flows, { namespace: 'shop', name: 'checkout' })
+    expect(n).toHaveLength(2)
+    expect(n).not.toContain(flows[2])
+  })
+
+  it('matches by namespace too: a same-named workload elsewhere is not the focus', () => {
+    const flows = [edge('other/checkout', 'shop/web')]
+    expect(focusNeighborhood(flows, { namespace: 'shop', name: 'checkout' })).toHaveLength(0)
+  })
+
+  // Ungrouped, the graph draws pods. A workload focus is then its pods.
+  it('matches a workload\'s pods when pods are not grouped', () => {
+    const pod = { namespace: 'shop', name: 'checkout-7d9-abc', kind: 'Pod', workload: 'checkout' }
+    expect(touchesFocus(pod, { namespace: 'shop', name: 'checkout' })).toBe(true)
+    expect(touchesFocus({ ...pod, kind: 'Service' }, { namespace: 'shop', name: 'checkout' })).toBe(false)
+  })
+})
+
+describe('endpoint search', () => {
+  const flows = [
+    edge('shop/checkout', 'shop/db', { connections: 5 }),
+    edge('shop/cart', 'shop/checkout', { connections: 50 }),
+    edge('shop/checkout-worker', 'shop/db', { connections: 1, verdictCounts: { dropped: 2 } }),
+  ]
+  const summaries = endpointSummaries(flows)
+
+  it('sums an endpoint\'s traffic across its edges, once per edge', () => {
+    const checkout = summaries.find(s => s.id === 'shop/checkout')!
+    expect(checkout.volume).toBe(55)
+    expect(endpointSummaries([edge('shop/a', 'shop/a', { connections: 3 })])[0].volume).toBe(3)
+  })
+
+  it('puts an exact name first, then prefixes, problems before volume', () => {
+    expect(searchEndpoints(summaries, 'checkout').map(s => s.name)).toEqual(['checkout', 'checkout-worker'])
+    const all = searchEndpoints(summaries, 'c').map(s => s.name)
+    expect(all.indexOf('checkout-worker')).toBeLessThan(all.indexOf('cart'))
+  })
+
+  it('offers the workload of pods drawn ungrouped, as well as the pods', () => {
+    const pod = (name: string) => ({ namespace: 'shop', name, kind: 'Pod', workload: 'checkout', workloadKind: 'Deployment' })
+    const flows = [
+      { ...edge('shop/web', 'shop/db'), source: pod('checkout-1') },
+      { ...edge('shop/web', 'shop/db'), source: pod('checkout-2') },
+    ]
+    const found = searchEndpoints(endpointSummaries(flows), 'checkout')
+    expect(found[0]).toMatchObject({ id: 'shop/checkout', kind: 'Workload', volume: 2 })
+    expect(found.map(s => s.name)).toContain('checkout-1')
+  })
+
+  it('finds nothing for a name with no traffic', () => {
+    expect(searchEndpoints(summaries, 'payments')).toEqual([])
+  })
+})
+
+describe('namespaceSummaries', () => {
+  // Narrowing to a namespace keeps edges with either end in it, as the server
+  // does, so a cross-namespace edge belongs to both.
+  it('counts a cross-namespace edge toward both namespaces', () => {
+    const s = namespaceSummaries([edge('shop/web', 'pay/api'), edge('shop/web', 'shop/db')])
+    const shop = s.find(n => n.name === 'shop')!
+    const pay = s.find(n => n.name === 'pay')!
+    expect(shop.connections).toBe(2)
+    expect(pay.connections).toBe(1)
+    expect(pay.endpoints).toBe(2)
+  })
+
+  it('ranks the namespace with failures first', () => {
+    const s = namespaceSummaries([
+      edge('big/a', 'big/b', { connections: 1000 }),
+      edge('small/a', 'small/b', { connections: 1, httpStatusCounts: { '5xx': 1 } }),
+    ])
+    expect(s.map(n => n.name)).toEqual(['small', 'big'])
+  })
+
+  it('skips endpoints without a namespace', () => {
+    expect(namespaceSummaries([edge('shop/web', 'api.stripe.com')]).map(n => n.name)).toEqual(['shop'])
+  })
+  // A hub's namespace is the case that sends a user from one too-large screen
+  // to the next: its many callees in other namespaces stay in view.
+  it('marks a namespace whose own view is over the draw budget', () => {
+    const hub = Array.from({ length: 250 }, (_, i) => edge('edge/gateway', `team-${i % 10}/svc-${i}`))
+    const s = namespaceSummaries([...hub, edge('quiet/a', 'quiet/b')])
+    expect(namespaceOverBudget(s.find(n => n.name === 'edge')!)).toBe(true)
+    expect(namespaceOverBudget(s.find(n => n.name === 'quiet')!)).toBe(false)
+    expect(namespaceOverBudget(s.find(n => n.name === 'team-0')!)).toBe(false)
+  })
+})
+
+describe('hasStatusData', () => {
+  it('tells an edge without HTTP status from one with no 5xx', () => {
+    expect(hasStatusData(edge('a/x', 'a/y'))).toBe(false)
+    expect(hasStatusData(edge('a/x', 'a/y', { httpStatusCounts: { '2xx': 5 } }))).toBe(true)
+    // A healthy metrics-based edge: its zero error rate is not sent.
+    expect(hasStatusData(edge('a/x', 'a/y', { requestRate: 2.5 }))).toBe(true)
+    expect(hasStatusData(edge('a/x', 'a/y', { l7Protocol: 'HTTP' }))).toBe(true)
+    expect(hasStatusData(edge('a/x', 'a/y', { l7Protocol: 'DNS' }))).toBe(false)
+  })
+})
+
+describe('connectionRows', () => {
+  it('lists failing edges first, then by volume', () => {
+    const quiet = edge('a/x', 'a/y', { connections: 1 })
+    const busy = edge('a/x', 'a/z', { connections: 100 })
+    const dropping = edge('a/x', 'a/w', { connections: 2, verdictCounts: { dropped: 1 } })
+    const erroring = edge('a/x', 'a/v', { connections: 2, errorRate: 0.5 })
+    expect(connectionRows([quiet, busy, erroring, dropping])).toEqual([dropping, erroring, busy, quiet])
+  })
+})
+
+describe('mergeFlowVolume problem counts', () => {
+  it('sums status and verdict counts without touching the merged edges', () => {
+    const a = edge('a/x', 'ext', { httpStatusCounts: { '5xx': 1 }, verdictCounts: { dropped: 2 } })
+    const b = edge('a/y', 'ext', { httpStatusCounts: { '5xx': 3, '2xx': 4 }, verdictCounts: { forwarded: 5 } })
+    const merged = { ...a }
+    mergeFlowVolume(merged, b)
+    expect(merged.httpStatusCounts).toEqual({ '5xx': 4, '2xx': 4 })
+    expect(merged.verdictCounts).toEqual({ dropped: 2, forwarded: 5 })
+    expect(a.httpStatusCounts).toEqual({ '5xx': 1 })
+  })
+})
+
+describe('selectionMatch', () => {
+  const traced = (f: AggregatedFlow): GraphFlow => ({ ...f, rawPairs: [endpointPair(f)] })
+
+  // A busy node has more edges than a URL can name; as one endpoint it is
+  // one entry however many it has.
+  it('sends a node that is one server endpoint as that endpoint', () => {
+    const flows = Array.from({ length: 400 }, (_, i) => traced(edge('edge/gateway', `t/svc-${i}`)))
+    const node = { type: 'node' as const, nodeId: 'edge/gateway' }
+    const m = selectionMatch(selectionRawPairs(flows, node), node)
+    expect(m).toEqual({ endpoints: [expect.objectContaining({ namespace: 'edge', name: 'gateway' })] })
+  })
+
+  it('sends a node the source cannot name, such as an external one, as its edges', () => {
+    const flows = [traced(edge('a/web', 'api.stripe.com')), traced(edge('a/job', 'api.stripe.com'))]
+    const node = { type: 'node' as const, nodeId: 'api.stripe.com' }
+    expect(selectionMatch(selectionRawPairs(flows, node), node)).toHaveProperty('pairs')
+  })
+
+  it('sends an edge, and a node merged from several endpoints, as edges', () => {
+    const a = traced(edge('a/web', 'a/db'))
+    const e = { type: 'edge' as const, sourceId: 'a/web', destId: 'a/db', port: 80 }
+    expect(selectionMatch(selectionRawPairs([a], e), e)).toHaveProperty('pairs')
+    // An external name the graph merged from two addresses.
+    const merged: GraphFlow = { ...edge('a/web', 'MongoDB'), rawPairs: [endpointPair(edge('a/web', '10.0.0.1')), endpointPair(edge('a/web', '10.0.0.2'))] }
+    const mongo = { type: 'node' as const, nodeId: 'MongoDB' }
+    expect(selectionMatch(selectionRawPairs([merged], mongo), mongo)).toHaveProperty('pairs')
+  })
+})
+
+describe('edgeCarriesPort', () => {
+  // A merged edge shows one of its ports; a selection made on another must
+  // still find it.
+  it('finds a port merged into the edge, not just the one it shows', () => {
+    const merged: GraphFlow = { ...edge('a/web', 'a/db'), port: 5432, rawPairs: [endpointPair({ ...edge('a/web', 'a/db'), port: 5432 }), endpointPair({ ...edge('a/web', 'a/db'), port: 6379 })] }
+    expect(edgeCarriesPort(merged, 6379)).toBe(true)
+    expect(edgeCarriesPort(merged, 5432)).toBe(true)
+    expect(edgeCarriesPort(merged, 80)).toBe(false)
+    expect(edgeCarriesPort(merged, undefined)).toBe(true)
+  })
+})
+
+describe('selectedEdgeMatcher', () => {
+  const ep = (namespace: string, name: string) => ({ name, namespace, kind: 'Pod' })
+  const record = (src: string, dst: string, port: number): TrafficFlow => ({
+    source: ep('shop', src), destination: ep('shop', dst), protocol: 'tcp', port,
+    connections: 1, bytesSent: 0, bytesRecv: 0, lastSeen: '2025-01-01T00:00:00Z',
+  } as TrafficFlow)
+  const pairs = [{ source: ep('shop', 'web'), destination: ep('shop', 'api'), port: 8080 }]
+  const asDrawn = (e: TrafficFlow['source']) => e
+
+  it('matches the selected edge, by endpoints, direction and port', () => {
+    const on = selectedEdgeMatcher(pairs, true, asDrawn)
+    expect(on(record('web', 'api', 8080))).toBe(true)
+    expect(on(record('web', 'api', 9090))).toBe(false)
+    expect(on(record('api', 'web', 41234))).toBe(false)
+  })
+
+  // A server that doesn't orient responses sends one server to
+  // client on the client's ephemeral port; dropping it would leave requests looking
+  // unanswered.
+  it('keeps a reversed response from a Radar that does not orient responses', () => {
+    const on = selectedEdgeMatcher(pairs, false, asDrawn)
+    const response = { ...record('api', 'web', 41234), l7Protocol: 'HTTP', l7Type: 'RESPONSE' }
+    expect(on(response)).toBe(true)
+    expect(on(record('web', 'db', 5432))).toBe(false)
+  })
+
+  it('does not take other traffic between the endpoints, which is on edges of its own', () => {
+    const on = selectedEdgeMatcher(pairs, false, asDrawn)
+    expect(on(record('web', 'api', 9090))).toBe(false) // a request on another port
+    expect(on(record('api', 'web', 5432))).toBe(false) // TCP the other way
+    expect(on({ ...record('api', 'web', 41234), l7Protocol: 'HTTP', l7Type: 'REQUEST' })).toBe(false) // the callee calling back
+    expect(selectedEdgeMatcher(pairs, true, asDrawn)({ ...record('api', 'web', 41234), l7Protocol: 'HTTP', l7Type: 'RESPONSE' })).toBe(false)
+  })
+
+  // Known and unavoidable: the response carries the client's port, so with
+  // two edges web→api on different ports it belongs to either.
+  it('matches an old Radar\'s response to each of the caller\'s edges', () => {
+    const on = selectedEdgeMatcher([{ source: ep('shop', 'web'), destination: ep('shop', 'api'), port: 9090 }], false, asDrawn)
+    expect(on({ ...record('api', 'web', 41234), l7Protocol: 'HTTP', l7Type: 'RESPONSE' })).toBe(true)
+  })
+
+  it('matches everything with no selection', () => {
+    expect(selectedEdgeMatcher(null, true, asDrawn)(record('a', 'b', 1))).toBe(true)
+  })
+})
+
+describe('edgesOnPort', () => {
+  // Default view: one client calling 80 and 443 merges into one edge shown on
+  // :80, while the Internet node keeps another client's :443 apart, so two
+  // edges join the same endpoints.
+  const merged: GraphFlow = { ...edge('internet', 'web/ingress'), port: 80, rawPairs: [endpointPair({ ...edge('internet', 'web/ingress'), port: 80 }), endpointPair({ ...edge('internet', 'web/ingress'), port: 443 })] }
+  const tls: GraphFlow = { ...edge('internet', 'web/ingress'), port: 443, rawPairs: [endpointPair({ ...edge('internet', 'web/ingress'), port: 443 })] }
+
+  it('prefers the edge shown on the port over one that only carries it', () => {
+    expect(edgesOnPort([merged, tls], f => f, 443)).toEqual([tls])
+    expect(edgesOnPort([merged, tls], f => f, 80)).toEqual([merged])
+  })
+
+  it('falls back to an edge the port was merged into', () => {
+    expect(edgesOnPort([merged], f => f, 443)).toEqual([merged])
+    expect(edgesOnPort([merged, tls], f => f, 8443)).toEqual([])
+  })
+
+  it('keeps a selection on the :443 edge to that edge\'s records', () => {
+    const sel = { type: 'edge' as const, sourceId: 'internet', destId: 'web/ingress', port: 443 }
+    expect(selectionRawPairs([merged, tls], sel)).toEqual(tls.rawPairs)
+  })
+})
+
+describe('mergedEdgePort', () => {
+  it('shows the lowest port whatever order the parts arrive in', () => {
+    expect(mergedEdgePort(443, 80)).toBe(80)
+    expect(mergedEdgePort(80, 443)).toBe(80)
+  })
+
+  // Port 0 is "none reported" (ICMP, or a record without one): a few such
+  // records must not hide the real port.
+  it('ignores port 0 unless no part has a port', () => {
+    expect(mergedEdgePort(0, 5432)).toBe(5432)
+    expect(mergedEdgePort(5432, 0)).toBe(5432)
+    expect(mergedEdgePort(0, 0)).toBe(0)
+  })
+})