diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index 495d06c5f..8f186e531 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -369,6 +369,11 @@ jobs: # (#89). See the file header for the rows and expected classes. run: sqlite3 test-fixtures/e2e-fixture.db < test-fixtures/seed-2073-route-adverts.sql + - name: Seed an inactive observer node for #199 E2E + # Also after the migration: the fixture has no inactive_nodes table + # until corescope-migrate creates it. + run: sqlite3 test-fixtures/e2e-fixture.db < test-fixtures/seed-199-inactive-observer.sql + - name: Start Go server with fixture DB run: | fuser -k 13581/tcp 2>/dev/null || true @@ -439,6 +444,7 @@ jobs: BASE_URL=http://localhost:13581 node test-live-multibyte-only-e2e.js 2>&1 | tee -a e2e-output.txt BASE_URL=http://localhost:13581 node test-issue-125-live-toggles-early-e2e.js 2>&1 | tee -a e2e-output.txt BASE_URL=http://localhost:13581 node test-issue-1150-404-state-e2e.js 2>&1 | tee -a e2e-output.txt + BASE_URL=http://localhost:13581 node test-issue-199-inactive-observer-e2e.js 2>&1 | tee -a e2e-output.txt BASE_URL=http://localhost:13581 node test-issue-1146-path-link-contrast-e2e.js 2>&1 | tee -a e2e-output.txt CHROMIUM_REQUIRE=1 node test-issue-1705-subpath-contrast-e2e.js 2>&1 | tee -a e2e-output.txt BASE_URL=http://localhost:13581 node test-issue-1147-section-order-e2e.js 2>&1 | tee -a e2e-output.txt diff --git a/cmd/ingestor/db.go b/cmd/ingestor/db.go index 042af9153..ed2019524 100644 --- a/cmd/ingestor/db.go +++ b/cmd/ingestor/db.go @@ -1895,6 +1895,16 @@ func (s *Store) LogStats() { ) } +// staleNodesWhere selects the nodes MoveStaleNodes retires: no advert in +// nodeDays (?1 = cutoff), unless the pubkey is an observer seen since the +// cutoff (#199). An observer never hears its own adverts, so an online +// observer can go nodeDays without one reaching another observer. last_seen +// stays the last advert. Observer ids arrive upper-case from the MQTT topic +// and node keys are lower-case, hence lower() on both sides; NULL ids are +// skipped because a single NULL makes NOT IN false for every node. +const staleNodesWhere = `last_seen < ?1 AND lower(public_key) NOT IN ( + SELECT lower(id) FROM observers WHERE id IS NOT NULL AND last_seen >= ?1)` + // MoveStaleNodes moves nodes not seen in nodeDays to the inactive_nodes table. // Returns the number of nodes moved. func (s *Store) MoveStaleNodes(nodeDays int) (int64, error) { @@ -1905,11 +1915,11 @@ func (s *Store) MoveStaleNodes(nodeDays int) (int64, error) { } defer tx.Rollback() - _, err = tx.Exec(`INSERT OR REPLACE INTO inactive_nodes SELECT * FROM nodes WHERE last_seen < ?`, cutoff) + _, err = tx.Exec(`INSERT OR REPLACE INTO inactive_nodes SELECT * FROM nodes WHERE `+staleNodesWhere, cutoff) if err != nil { return 0, fmt.Errorf("insert inactive: %w", err) } - result, err := tx.Exec(`DELETE FROM nodes WHERE last_seen < ?`, cutoff) + result, err := tx.Exec(`DELETE FROM nodes WHERE `+staleNodesWhere, cutoff) if err != nil { return 0, fmt.Errorf("delete stale: %w", err) } diff --git a/cmd/ingestor/issue199_test.go b/cmd/ingestor/issue199_test.go new file mode 100644 index 000000000..ff8567869 --- /dev/null +++ b/cmd/ingestor/issue199_test.go @@ -0,0 +1,118 @@ +package main + +import ( + "testing" + "time" +) + +// #199: MoveStaleNodes must not retire a node whose pubkey is an observer +// seen within nodeDays. An observer never hears its own adverts, so an +// online observer can go a week without one reaching another observer. + +const ( + issue199ObserverKey = "a199000000000000000000000000000000000000000000000000000000000001" + issue199QuietKey = "a199000000000000000000000000000000000000000000000000000000000002" + issue199PlainKey = "a199000000000000000000000000000000000000000000000000000000000003" + issue199OldAdvert = "2020-01-01T00:00:00Z" +) + +func issue199Upper(s string) string { + b := []byte(s) + for i, c := range b { + if c >= 'a' && c <= 'z' { + b[i] = c - 'a' + 'A' + } + } + return string(b) +} + +func issue199NodeIn(t *testing.T, store *Store, table, pubkey string) (bool, string) { + t.Helper() + var lastSeen string + err := store.db.QueryRow(`SELECT last_seen FROM `+table+` WHERE public_key = ?`, pubkey).Scan(&lastSeen) + if err != nil { + return false, "" + } + return true, lastSeen +} + +func issue199Observer(t *testing.T, store *Store, id, lastSeen string) { + t.Helper() + if _, err := store.db.Exec(`INSERT INTO observers (id, name, last_seen, first_seen) VALUES (?, 'obs', ?, ?)`, id, lastSeen, lastSeen); err != nil { + t.Fatal(err) + } +} + +func TestMoveStaleNodesKeepsActiveObserverNode(t *testing.T) { + store := newTestStore(t) + if err := store.UpsertNode(issue199ObserverKey, "ObsRepeater", "repeater", nil, nil, issue199OldAdvert); err != nil { + t.Fatal(err) + } + // Observer ids are upper-case pubkeys from the MQTT topic; node keys are lower-case. + issue199Observer(t, store, issue199Upper(issue199ObserverKey), time.Now().UTC().Format(time.RFC3339)) + + moved, err := store.MoveStaleNodes(7) + if err != nil { + t.Fatal(err) + } + if moved != 0 { + t.Errorf("moved=%d, want 0: an observer seen within nodeDays must stay a node", moved) + } + in, lastSeen := issue199NodeIn(t, store, "nodes", issue199ObserverKey) + if !in { + t.Fatal("active observer's node was removed from nodes") + } + if lastSeen != issue199OldAdvert { + t.Errorf("last_seen=%q, want %q: last_seen is the last advert and must not be faked", lastSeen, issue199OldAdvert) + } + if in, _ := issue199NodeIn(t, store, "inactive_nodes", issue199ObserverKey); in { + t.Error("active observer's node was copied to inactive_nodes") + } +} + +func TestMoveStaleNodesRetiresQuietObserverAndPlainNode(t *testing.T) { + store := newTestStore(t) + for _, pk := range []string{issue199QuietKey, issue199PlainKey} { + if err := store.UpsertNode(pk, "Stale", "repeater", nil, nil, issue199OldAdvert); err != nil { + t.Fatal(err) + } + } + // Last heard as an observer 8 days ago: outside the 7-day window. + issue199Observer(t, store, issue199Upper(issue199QuietKey), time.Now().UTC().AddDate(0, 0, -8).Format(time.RFC3339)) + + moved, err := store.MoveStaleNodes(7) + if err != nil { + t.Fatal(err) + } + if moved != 2 { + t.Errorf("moved=%d, want 2", moved) + } + for _, pk := range []string{issue199QuietKey, issue199PlainKey} { + if in, _ := issue199NodeIn(t, store, "nodes", pk); in { + t.Errorf("%s still in nodes, want retired", pk[:8]) + } + if in, _ := issue199NodeIn(t, store, "inactive_nodes", pk); !in { + t.Errorf("%s missing from inactive_nodes", pk[:8]) + } + } +} + +// A legacy observers row with a NULL id must not stop retention: with a bare +// NOT IN, one NULL in the subquery makes the predicate NULL for every node. +func TestMoveStaleNodesNullObserverIDDoesNotBlockRetention(t *testing.T) { + store := newTestStore(t) + if err := store.UpsertNode(issue199PlainKey, "Stale", "companion", nil, nil, issue199OldAdvert); err != nil { + t.Fatal(err) + } + if _, err := store.db.Exec(`INSERT INTO observers (id, name, last_seen) VALUES (NULL, 'legacy', ?)`, time.Now().UTC().Format(time.RFC3339)); err != nil { + t.Fatal(err) + } + + moved, err := store.MoveStaleNodes(7) + if err != nil { + t.Fatal(err) + } + if moved != 1 { + t.Errorf("moved=%d, want 1", moved) + } +} diff --git a/cmd/server/issue199_node_not_found_test.go b/cmd/server/issue199_node_not_found_test.go new file mode 100644 index 000000000..086dbdbaf --- /dev/null +++ b/cmd/server/issue199_node_not_found_test.go @@ -0,0 +1,155 @@ +package main + +import ( + "encoding/json" + "net/http/httptest" + "strings" + "testing" + + "github.com/gorilla/mux" +) + +// #199: a 404 from /api/nodes/{pubkey} carries what the instance still knows +// about the key -- its inactive_nodes row and/or its observer row -- so the +// node page can explain the state instead of dead-ending on "Node not found". + +const ( + issue199InactiveObs = "b199000000000000000000000000000000000000000000000000000000000001" + issue199ObsOnly = "b199000000000000000000000000000000000000000000000000000000000002" + issue199Unknown = "b199000000000000000000000000000000000000000000000000000000000003" +) + +// Decoded locally (not via the server's types) so the contract is pinned by +// its JSON field names. +type issue199Inactive struct { + PublicKey string `json:"public_key"` + Name string `json:"name"` + Role string `json:"role"` + LastSeen string `json:"last_seen"` +} + +type issue199Observer struct { + ID string `json:"id"` + Name string `json:"name"` + LastSeen string `json:"last_seen"` +} + +func issue199Get(t *testing.T, router *mux.Router, pubkey string) (int, map[string]json.RawMessage) { + t.Helper() + req := httptest.NewRequest("GET", "/api/nodes/"+pubkey, nil) + w := httptest.NewRecorder() + router.ServeHTTP(w, req) + var body map[string]json.RawMessage + if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil { + t.Fatalf("decode %q: %v", w.Body.String(), err) + } + return w.Code, body +} + +func issue199Seed(t *testing.T, srv *Server) { + t.Helper() + ensureInactiveNodesTable(t, srv) + if _, err := srv.db.conn.Exec(`INSERT INTO inactive_nodes (public_key, name, role, last_seen, first_seen) VALUES (?, 'Quiet Repeater', 'repeater', '2026-09-24T15:35:00Z', '2026-09-11T00:00:00Z')`, issue199InactiveObs); err != nil { + t.Fatal(err) + } + for _, o := range []struct{ id, name string }{ + {strings.ToUpper(issue199InactiveObs), "Quiet Observer"}, + {strings.ToUpper(issue199ObsOnly), "Listener Only"}, + } { + if _, err := srv.db.conn.Exec(`INSERT INTO observers (id, name, last_seen, first_seen) VALUES (?, ?, '2026-10-04T04:23:00Z', '2026-09-11T00:00:00Z')`, o.id, o.name); err != nil { + t.Fatal(err) + } + } +} + +func TestNodeDetail404CarriesInactiveNodeAndObserver(t *testing.T) { + srv, router := setupTestServer(t) + issue199Seed(t, srv) + + code, body := issue199Get(t, router, issue199InactiveObs) + if code != 404 { + t.Fatalf("status=%d, want 404 (the node is not in nodes)", code) + } + var inactive issue199Inactive + if err := json.Unmarshal(body["inactive_node"], &inactive); err != nil { + t.Fatalf("inactive_node missing or malformed: %v (body %v)", err, body) + } + if inactive.PublicKey != issue199InactiveObs || inactive.Name != "Quiet Repeater" || inactive.Role != "repeater" || inactive.LastSeen != "2026-09-24T15:35:00Z" { + t.Errorf("inactive_node=%+v", inactive) + } + var obs issue199Observer + if err := json.Unmarshal(body["observer"], &obs); err != nil { + t.Fatalf("observer missing or malformed: %v (body %v)", err, body) + } + if obs.ID != strings.ToUpper(issue199InactiveObs) || obs.Name != "Quiet Observer" || obs.LastSeen != "2026-10-04T04:23:00Z" { + t.Errorf("observer=%+v", obs) + } + + // Upper-case path (as an observer id) finds the same rows. + if _, body := issue199Get(t, router, strings.ToUpper(issue199InactiveObs)); body["inactive_node"] == nil { + t.Error("upper-case pubkey did not find the inactive_nodes row") + } +} + +func TestNodeDetail404ObserverWithoutNodeRecord(t *testing.T) { + srv, router := setupTestServer(t) + issue199Seed(t, srv) + + code, body := issue199Get(t, router, issue199ObsOnly) + if code != 404 { + t.Fatalf("status=%d, want 404", code) + } + if body["inactive_node"] != nil { + t.Errorf("unexpected inactive_node: %s", body["inactive_node"]) + } + var obs issue199Observer + if err := json.Unmarshal(body["observer"], &obs); err != nil || obs.Name != "Listener Only" { + t.Errorf("observer=%+v err=%v", obs, err) + } +} + +func TestNodeDetail404UnknownStaysBare(t *testing.T) { + srv, router := setupTestServer(t) + issue199Seed(t, srv) + + code, body := issue199Get(t, router, issue199Unknown) + if code != 404 || len(body) != 1 || body["error"] == nil { + t.Errorf("status=%d body=%v, want 404 with only an error field", code, body) + } +} + +// Without an inactive_nodes table (minimal schemas) the observer still counts. +func TestNodeDetail404WithoutInactiveTable(t *testing.T) { + srv, router := setupTestServer(t) + if _, err := srv.db.conn.Exec(`INSERT INTO observers (id, name, last_seen) VALUES (?, 'Listener Only', '2026-10-04T04:23:00Z')`, strings.ToUpper(issue199ObsOnly)); err != nil { + t.Fatal(err) + } + code, body := issue199Get(t, router, issue199ObsOnly) + if code != 404 || body["observer"] == nil || body["inactive_node"] != nil { + t.Errorf("status=%d body=%v", code, body) + } +} + +// Blacklisted or hidden identities get the bare 404: nothing about the rows leaks. +func TestNodeDetail404HiddenIdentityStaysBare(t *testing.T) { + cases := []struct { + name string + setup func(*Server) + }{ + {"node blacklist", func(s *Server) { s.cfg.SetNodeBlacklist([]string{issue199InactiveObs}) }}, + {"observer blacklist", func(s *Server) { s.cfg.ObserverBlacklist = []string{strings.ToUpper(issue199InactiveObs)} }}, + {"hidden inactive name", func(s *Server) { s.cfg.SetHiddenNamePrefixes([]string{"Quiet Rep"}) }}, + {"hidden observer name", func(s *Server) { s.cfg.SetHiddenNamePrefixes([]string{"Quiet Obs"}) }}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + srv, router := setupTestServer(t) + issue199Seed(t, srv) + tc.setup(srv) + code, body := issue199Get(t, router, issue199InactiveObs) + if code != 404 || len(body) != 1 || body["error"] == nil { + t.Errorf("status=%d body=%v, want bare 404", code, body) + } + }) + } +} diff --git a/cmd/server/node_not_found.go b/cmd/server/node_not_found.go new file mode 100644 index 000000000..22b3657c9 --- /dev/null +++ b/cmd/server/node_not_found.go @@ -0,0 +1,108 @@ +package main + +import ( + "context" + "database/sql" + "encoding/json" + "errors" + "log" + "net/http" + "strings" +) + +// nodeNotFoundResponse is the 404 body of GET /api/nodes/{pubkey} (#199). +// Beyond the error it carries what this instance still knows about the key, +// so the node page can explain the state instead of dead-ending on +// "Node not found": +// - InactiveNode: the inactive_nodes row, i.e. the node was retired by the +// ingestor's retention (no advert in retention.nodeDays). LastSeen is the +// last advert. +// - Observer: the observers row, when the pubkey also uploads as an +// observer (an observer may never have had a node row at all). +// +// Both are omitted for an unknown key, and for a blacklisted or hidden +// identity, whose 404 stays bare. +type nodeNotFoundResponse struct { + Error string `json:"error"` + InactiveNode *inactiveNodeInfo `json:"inactive_node,omitempty"` + Observer *observerRef `json:"observer,omitempty"` +} + +type inactiveNodeInfo struct { + PublicKey string `json:"public_key"` + Name string `json:"name"` + Role string `json:"role"` + LastSeen string `json:"last_seen"` + FirstSeen string `json:"first_seen"` +} + +type observerRef struct { + ID string `json:"id"` + Name string `json:"name"` + LastSeen string `json:"last_seen"` +} + +// lookupMissingNode builds the 404 body for a pubkey that has no nodes row: +// two read-only primary-key-sized lookups, run only on that 404 path. The +// visibility rule is identityHidden, applied to both names found here. +func (s *Server) lookupMissingNode(ctx context.Context, pubkey string) (nodeNotFoundResponse, error) { + resp := nodeNotFoundResponse{Error: "Not found"} + if s.db == nil || s.db.conn == nil { + return resp, nil + } + pk := strings.ToLower(pubkey) + + hasInactive, err := s.hasInactiveNodesTable(ctx) + if err != nil { + return resp, err + } + if hasInactive { + var n inactiveNodeInfo + err := s.db.conn.QueryRowContext(ctx, `SELECT public_key, COALESCE(name, ''), COALESCE(role, ''), COALESCE(last_seen, ''), COALESCE(first_seen, '') + FROM inactive_nodes WHERE public_key = ?`, pk).Scan(&n.PublicKey, &n.Name, &n.Role, &n.LastSeen, &n.FirstSeen) + switch { + case err == nil: + resp.InactiveNode = &n + case !errors.Is(err, sql.ErrNoRows): + return resp, err + } + } + + // Observer ids arrive raw from the MQTT topic in any case; the table is + // small, and this runs once per missing-node page view. + var o observerRef + err = s.db.conn.QueryRowContext(ctx, `SELECT id, COALESCE(name, ''), COALESCE(last_seen, '') + FROM observers WHERE lower(id) = ? ORDER BY last_seen DESC LIMIT 1`, pk).Scan(&o.ID, &o.Name, &o.LastSeen) + switch { + case err == nil: + resp.Observer = &o + case !errors.Is(err, sql.ErrNoRows): + return resp, err + } + + var names []string + if resp.InactiveNode != nil { + names = append(names, resp.InactiveNode.Name) + } + if resp.Observer != nil { + names = append(names, resp.Observer.Name) + } + if identityHidden(s.cfg, pk, names...) { + return nodeNotFoundResponse{Error: "Not found"}, nil + } + return resp, nil +} + +// writeNodeNotFound answers a node-detail miss. A failed lookup falls back to +// the bare 404: it only enriches the error and must not turn it into a 500. +func (s *Server) writeNodeNotFound(w http.ResponseWriter, r *http.Request, pubkey string) { + resp, err := s.lookupMissingNode(r.Context(), pubkey) + if err != nil { + resp = nodeNotFoundResponse{Error: "Not found"} + } + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusNotFound) + if err := json.NewEncoder(w).Encode(resp); err != nil { + log.Printf("[routes] JSON encode error: %v", err) + } +} diff --git a/cmd/server/openapi.go b/cmd/server/openapi.go index 0afe3f571..3f6ccb8bf 100644 --- a/cmd/server/openapi.go +++ b/cmd/server/openapi.go @@ -87,7 +87,7 @@ func routeDescriptions() map[string]routeMeta { "GET /api/nodes/search": {Summary: "Search nodes", Description: "Search nodes by name or public key prefix.", Tag: "nodes", QueryParams: []paramMeta{{Name: "q", Description: "Search query", Type: "string", Required: true}}}, "GET /api/nodes/bulk-health": {Summary: "Bulk node health", Description: "Returns health status for all nodes in one call.", Tag: "nodes"}, "GET /api/nodes/network-status": {Summary: "Network status summary", Description: "Returns counts of active, stale, and offline nodes.", Tag: "nodes"}, - "GET /api/nodes/{pubkey}": {Summary: "Get node detail", Description: "Returns full detail for a single node by public key. For repeater/room nodes this includes the issue #672 usefulness axes + composite score/grade (see the Node schema). recentAdverts is the chronological list; with include=advertRoutes, recentAdvertsByRoute and advertCounts (#2073) split the node's adverts into flood / zero_hop / mixed and the ADVERT rows of recentAdverts carry route_class.", Tag: "nodes", Response: schemaRef("NodeDetailResponse"), + "GET /api/nodes/{pubkey}": {Summary: "Get node detail", Description: "Returns full detail for a single node by public key. For repeater/room nodes this includes the issue #672 usefulness axes + composite score/grade (see the Node schema). recentAdverts is the chronological list; with include=advertRoutes, recentAdvertsByRoute and advertCounts (#2073) split the node's adverts into flood / zero_hop / mixed and the ADVERT rows of recentAdverts carry route_class. A 404 for a key with no nodes row (#199) is {error, inactive_node?, observer?}: inactive_node {public_key, name, role, last_seen, first_seen} is the inactive_nodes row when retention retired the node (no advert in retention.nodeDays; last_seen is the last advert), observer {id, name, last_seen} is the observers row when the key uploads as an observer. Both are omitted for an unknown key and for a blacklisted or hidden identity.", Tag: "nodes", Response: schemaRef("NodeDetailResponse"), QueryParams: []paramMeta{ {Name: "include", Description: "Opt-in extras, comma-separated (the parameter may also repeat). advertRoutes (#2073): adds recentAdvertsByRoute, advertCounts and route_class on the recentAdverts ADVERT rows. That costs a scan of all the node's ADVERT rows (cached per node for up to 30 s), so only the node page asks for it; without it the response has neither field and no route_class. Unknown values are ignored. Hidden identities never get the extras.", Type: "string"}, }}, diff --git a/cmd/server/routes.go b/cmd/server/routes.go index 30f1c5e70..e2ce37ea0 100644 --- a/cmd/server/routes.go +++ b/cmd/server/routes.go @@ -2038,7 +2038,7 @@ func (s *Server) handleNodeDetail(w http.ResponseWriter, r *http.Request) { } } if node == nil { - writeError(w, 404, "Not found") + s.writeNodeNotFound(w, r, pubkey) return } // Hide the node when its name matches an operator-configured prefix diff --git a/public/app.js b/public/app.js index 960be42b3..425e82e35 100644 --- a/public/app.js +++ b/public/app.js @@ -195,6 +195,9 @@ async function api(path, { ttl = 0, bust = false, retry503 = true } = {}) { err.status = res.status; const ra = parseInt(res.headers.get('Retry-After'), 10); if (res.status === 503 && isFinite(ra) && ra > 0) err.retryAfterSeconds = ra; + // #199: a JSON error body travels as err.body (e.g. the node-detail + // 404's inactive_node / observer); a non-JSON body leaves it unset. + try { err.body = await res.json(); } catch (_) { /* not JSON */ } throw err; } const data = await res.json(); diff --git a/public/nodes.js b/public/nodes.js index c91de427e..2e1aa4c4e 100644 --- a/public/nodes.js +++ b/public/nodes.js @@ -696,6 +696,51 @@ return nodeData; } + /** + * #199: the node page for a key with no nodes row. The 404 body of + * /api/nodes/{pubkey} carries the key's inactive_nodes row (retired after + * retention.nodeDays without an advert) and/or its observer row. Returns + * { title, html } explaining that state, or null when the instance knows + * nothing about the key (the generic "Node not found" then stays). + */ + function missingNodeView(pubkey, notFound) { + const inactive = notFound && notFound.inactive_node; + const observer = notFound && notFound.observer; + if (!inactive && !observer) return null; + const name = (inactive && inactive.name) || (observer && observer.name) || ''; + const when = (iso) => '' + escapeHtml(formatAbsoluteTimestamp(iso)) + ''; + const rows = []; + let headline, explanation; + if (inactive) { + headline = 'Inactive node'; + explanation = 'No advert heard since ' + when(inactive.last_seen) + '; this device is inactive. ' + + 'Nodes without an advert inside the retention window are moved off the node list until they advertise again.'; + rows.push(['Name', escapeHtml(inactive.name || '—')], ['Role', escapeHtml(inactive.role || '—')], ['Last advert', when(inactive.last_seen)]); + } else { + headline = 'No node record'; + explanation = 'This device uploads as an observer, but no advert from it has been heard here, so it has no node record.'; + rows.push(['Name', escapeHtml(observer.name || '—')]); + } + if (observer) rows.push(['Last upload as observer', when(observer.last_seen)]); + const observerLink = observer + ? 'View observer →' + : ''; + const html = + '
' + + '
' + headline + '
' + + '
' + escapeHtml(pubkey || '') + '
' + + '

' + explanation + '

' + + '
' + + rows.map(r => '
' + r[0] + '
' + r[1] + '
').join('') + + '
' + + '
' + + observerLink + + '← Back to Nodes' + + '
' + + '
'; + return { title: name || (pubkey || '').slice(0, 12) + '…', html }; + } + async function loadFullNode(pubkey) { const body = document.getElementById('nodeFullBody'); const viewSeq = ++detailViewSeq; @@ -1131,6 +1176,13 @@ const msg = (e && e.message) || ''; const is404 = /\b404\b/.test(msg) || /not\s*found/i.test(msg); const titleEl = document.querySelector('.node-full-title'); + const missing = is404 ? missingNodeView(pubkey, e && e.body) : null; + if (missing) { + if (titleEl) titleEl.textContent = missing.title; + removeDetailMap(); + body.innerHTML = missing.html; + return; + } if (titleEl) { titleEl.textContent = is404 ? 'Node not found — ' + (pubkey || '').slice(0, 12) + '…' @@ -2054,6 +2106,7 @@ // Test hooks window._nodesIsAdvertMessage = isAdvertMessage; + window._nodesMissingNodeView = missingNodeView; window._nodesGetAllNodes = function() { return _allNodes; }; window._nodesSetAllNodes = function(n) { _allNodes = n; }; window._nodesGetFiltered = function() { return nodes; }; diff --git a/test-all.sh b/test-all.sh index 1eb9ecff4..93e673d8d 100755 --- a/test-all.sh +++ b/test-all.sh @@ -205,6 +205,7 @@ run test-embed-mode-1369.js run test-geofilter-draft.js run test-hash-color.js run test-issue-1166-first-seen-column.js +run test-issue-199-missing-node.js run test-issue-1189-composed-cell.js run test-issue-1189-live-iata-badge.js run test-issue-1415-packets-layout.js diff --git a/test-fixtures/seed-199-inactive-observer.sql b/test-fixtures/seed-199-inactive-observer.sql new file mode 100644 index 000000000..1b0f46440 --- /dev/null +++ b/test-fixtures/seed-199-inactive-observer.sql @@ -0,0 +1,13 @@ +-- #199 E2E seed (test-issue-199-inactive-observer-e2e.js): an observer whose +-- node row was retired to inactive_nodes (retention.nodeDays without an +-- advert), the shape that dead-ended on "Node not found". +-- Applied by CI after the fixture is migrated (inactive_nodes must exist): +-- sqlite3 test-fixtures/e2e-fixture.db < test-fixtures/seed-199-inactive-observer.sql +-- +-- Reuses fixture observer 0D3B3F38... (no nodes row, no observations), so no +-- observer list or count changes for the other E2E tests. Its node row lives +-- only in inactive_nodes. Fixture observer 424419FD... stays as is: an +-- observer with no node record at all. +INSERT OR REPLACE INTO inactive_nodes (public_key, name, role, last_seen, first_seen, advert_count) VALUES + ('0d3b3f382173a49eb0e3bb01ab2ea9b28601d9039e4bd52c55b91a8000cc092d', 'Inactive Observer E2E', 'repeater', + strftime('%Y-%m-%dT%H:%M:%SZ', 'now', '-10 days'), strftime('%Y-%m-%dT%H:%M:%SZ', 'now', '-30 days'), 3); diff --git a/test-issue-199-inactive-observer-e2e.js b/test-issue-199-inactive-observer-e2e.js new file mode 100644 index 000000000..b606154a7 --- /dev/null +++ b/test-issue-199-inactive-observer-e2e.js @@ -0,0 +1,94 @@ +/** + * E2E (#199): from the Observers page, a device without a `nodes` row must not + * dead-end on a bare "Node not found". + * + * Needs test-fixtures/seed-199-inactive-observer.sql applied to the fixture: + * - observer 0D3B3F38... has its node row only in inactive_nodes, so the + * node page explains "No advert heard since ; this device is + * inactive" with the inactive row's name and role; + * - observer 424419FD... has no node record at all, so the node page says + * so and links back to the observer. + * + * Usage: BASE_URL=http://localhost:13581 node test-issue-199-inactive-observer-e2e.js + */ +'use strict'; +const { chromium } = require('playwright'); + +const BASE = process.env.BASE_URL || 'http://localhost:13581'; +const INACTIVE_OBS = '0D3B3F382173A49EB0E3BB01AB2EA9B28601D9039E4BD52C55B91A8000CC092D'; +const OBS_ONLY = '424419FDF9DD9D206A5A917979E56E843DE78E890359C70B9F59B7E2CF2CE392'; + +let passed = 0, failed = 0; +async function step(name, fn) { + try { await fn(); passed++; console.log(' ✓ ' + name); } + catch (e) { failed++; console.error(' ✗ ' + name + ': ' + e.message); } +} +function assert(c, m) { if (!c) throw new Error(m || 'assertion failed'); } + +async function settledNodePage(page) { + await page.waitForFunction(() => { + const el = document.querySelector('.node-full-title'); + return el && (el.textContent || '').trim() !== 'Loading…'; + }, { timeout: 10000 }); + return page.evaluate(() => { + const body = document.getElementById('nodeFullBody'); + const title = document.querySelector('.node-full-title'); + return { + title: title ? title.textContent.trim() : '', + text: body ? body.textContent : '', + hrefs: body ? Array.from(body.querySelectorAll('a[href]')).map(a => a.getAttribute('href')) : [], + }; + }); +} + +(async () => { + const browser = await chromium.launch({ + headless: true, + executablePath: process.env.CHROMIUM_PATH || undefined, + args: ['--no-sandbox', '--disable-gpu', '--disable-dev-shm-usage'], + }); + const ctx = await browser.newContext({ viewport: { width: 1400, height: 900 } }); + const page = await ctx.newPage(); + page.setDefaultTimeout(15000); + page.on('pageerror', (e) => console.error('[pageerror]', e.message)); + + console.log('\n=== #199 inactive observer node page E2E against ' + BASE + ' ==='); + + await step('GET /api/nodes/ is a 404 that carries the inactive row (precondition)', async () => { + const res = await page.request.get(BASE + '/api/nodes/' + INACTIVE_OBS.toLowerCase()); + assert(res.status() === 404, 'expected 404, got ' + res.status()); + const body = await res.json(); + assert(body.inactive_node && body.inactive_node.name === 'Inactive Observer E2E', + 'inactive_node missing (seed-199 applied?): ' + JSON.stringify(body)); + assert(body.observer && body.observer.id === INACTIVE_OBS, 'observer missing: ' + JSON.stringify(body)); + }); + + await step('observer detail → "View node detail" explains the inactive node', async () => { + await page.goto(BASE + '/#/observers/' + encodeURIComponent(INACTIVE_OBS), { waitUntil: 'domcontentloaded' }); + const link = page.locator('a', { hasText: 'View node detail' }); + await link.waitFor(); + await link.click(); + await page.waitForFunction(() => location.hash.indexOf('#/nodes/') === 0); + const r = await settledNodePage(page); + assert(r.text.indexOf('Node not found') === -1, 'dead-ended on "Node not found": ' + r.text.slice(0, 200)); + assert(/No advert heard since .+; this device is inactive/.test(r.text), 'missing inactive explanation: ' + r.text.slice(0, 300)); + assert(r.text.indexOf('Inactive Observer E2E') !== -1, 'inactive name missing'); + assert(/repeater/i.test(r.text), 'inactive role missing'); + assert(r.title.indexOf('Inactive Observer E2E') !== -1, 'title should name the device: ' + r.title); + assert(r.hrefs.indexOf('#/observers/' + encodeURIComponent(INACTIVE_OBS)) !== -1, 'observer link missing: ' + r.hrefs); + assert(r.hrefs.indexOf('#/nodes') !== -1, 'Back to Nodes link missing'); + }); + + await step('observer with no node record: node page says so and links the observer', async () => { + await page.goto(BASE + '/#/nodes/' + OBS_ONLY.toLowerCase(), { waitUntil: 'domcontentloaded' }); + const r = await settledNodePage(page); + assert(r.text.indexOf('Node not found') === -1, 'dead-ended on "Node not found"'); + assert(/no node record/i.test(r.text), 'missing "no node record" explanation: ' + r.text.slice(0, 300)); + assert(r.hrefs.indexOf('#/observers/' + encodeURIComponent(OBS_ONLY)) !== -1, 'observer link missing: ' + r.hrefs); + }); + + await browser.close(); + + console.log('\n--- ' + passed + ' passed, ' + failed + ' failed ---\n'); + process.exit(failed > 0 ? 1 : 0); +})().catch((e) => { console.error(e); process.exit(1); }); diff --git a/test-issue-199-missing-node.js b/test-issue-199-missing-node.js new file mode 100644 index 000000000..412e57b6a --- /dev/null +++ b/test-issue-199-missing-node.js @@ -0,0 +1,176 @@ +/* Issue #199: the node page must not dead-end on a bare "Node not found" for + * a device the instance still knows about. + * + * A 404 from /api/nodes/{pubkey} carries the key's inactive_nodes row + * (retired after retention.nodeDays without an advert) and/or its observer + * row. This test loads the real public/app.js and public/nodes.js in a vm + * sandbox and checks: + * 1. api() attaches a JSON error body to the thrown error (err.body); + * 2. the node page's missing-node view explains the inactive state with + * the inactive row's name and role, links the observer, escapes + * node-controlled text, and falls back (null) for an unknown key. + */ +'use strict'; +const vm = require('vm'); +const fs = require('fs'); +const assert = require('assert'); + +let passed = 0, failed = 0; +async function test(name, fn) { + try { await fn(); passed++; console.log(' ✅ ' + name); } + catch (e) { failed++; console.log(' ❌ ' + name + ': ' + e.message); } +} + +function makeSandbox(fetchImpl) { + const ctx = { + window: { addEventListener: () => {}, dispatchEvent: () => {} }, + document: { + readyState: 'complete', + createElement: () => ({ id: '', textContent: '', innerHTML: '' }), + head: { appendChild: () => {} }, + body: { appendChild: () => {} }, + getElementById: () => null, + addEventListener: () => {}, + querySelectorAll: () => [], + querySelector: () => null, + }, + console, Date, Infinity, Math, Array, Object, String, Number, JSON, RegExp, + Error, TypeError, parseInt, parseFloat, isNaN, isFinite, + encodeURIComponent, decodeURIComponent, + setTimeout, clearTimeout, + setInterval: () => {}, clearInterval: () => {}, + fetch: fetchImpl || (() => Promise.resolve({ ok: true, status: 200, headers: { get: () => null }, json: () => Promise.resolve({}) })), + performance: { now: () => Date.now() }, + localStorage: (() => { + const store = {}; + return { + getItem: k => store[k] || null, + setItem: (k, v) => { store[k] = String(v); }, + removeItem: k => { delete store[k]; }, + }; + })(), + location: { hash: '' }, + CustomEvent: class CustomEvent {}, + Map, Set, Promise, URLSearchParams, + addEventListener: () => {}, dispatchEvent: () => {}, + requestAnimationFrame: (cb) => setTimeout(cb, 0), + }; + ctx.getHashParams = function () { return new URLSearchParams(''); }; + ctx.registerPage = () => {}; + ctx.RegionFilter = { init: () => {}, getSelected: () => null, onRegionChange: () => {} }; + ctx.onWS = () => {}; + ctx.offWS = () => {}; + ctx.invalidateApiCache = () => {}; + ctx.favStar = () => ''; + ctx.bindFavStars = () => {}; + ctx.getFavorites = () => []; + ctx.isFavorite = () => false; + ctx.connectWS = () => {}; + ctx.HopResolver = { init: () => {}, resolve: () => ({}), ready: () => false }; + ctx.CLIENT_TTL = { nodeList: 90000, nodeDetail: 240000, nodeHealth: 240000 }; + ctx.initTabBar = () => {}; + ctx.makeColumnsResizable = () => {}; + ctx.debounce = (fn) => fn; + vm.createContext(ctx); + return ctx; +} +function loadInCtx(ctx, file) { + vm.runInContext(fs.readFileSync(file, 'utf8'), ctx); + for (const k of Object.keys(ctx.window)) ctx[k] = ctx.window[k]; +} + +const PK = 'b199000000000000000000000000000000000000000000000000000000000001'; +const OBS_ID = PK.toUpperCase(); +const NOT_FOUND = { + error: 'Not found', + inactive_node: { public_key: PK, name: 'Quiet Repeater', role: 'repeater', last_seen: '2026-09-24T15:35:00Z', first_seen: '2026-09-11T00:00:00Z' }, + observer: { id: OBS_ID, name: 'Quiet Observer', last_seen: '2026-10-04T04:23:00Z' }, +}; + +(async () => { + console.log('\n=== issue #199: missing-node explanation ==='); + + await test('api() attaches the JSON body of a 404 to the thrown error', async () => { + const ctx = makeSandbox(() => Promise.resolve({ + ok: false, status: 404, headers: { get: () => null }, + json: () => Promise.resolve(NOT_FOUND), + })); + loadInCtx(ctx, __dirname + '/public/app.js'); + let err = null; + try { await ctx.api('/nodes/' + PK); } catch (e) { err = e; } + assert.ok(err, 'api() should reject on 404'); + assert.strictEqual(err.status, 404); + assert.ok(/API 404/.test(err.message), 'message unchanged: ' + err.message); + assert.ok(err.body && err.body.inactive_node, 'err.body.inactive_node missing'); + assert.strictEqual(err.body.inactive_node.name, 'Quiet Repeater'); + }); + + await test('api() still rejects normally when the error body is not JSON', async () => { + const ctx = makeSandbox(() => Promise.resolve({ + ok: false, status: 500, headers: { get: () => null }, + json: () => Promise.reject(new SyntaxError('Unexpected token')), + })); + loadInCtx(ctx, __dirname + '/public/app.js'); + let err = null; + try { await ctx.api('/broken'); } catch (e) { err = e; } + assert.ok(err && err.status === 500 && /API 500/.test(err.message), 'got ' + (err && err.message)); + assert.strictEqual(err.body, undefined); + }); + + const ctx = makeSandbox(); + loadInCtx(ctx, __dirname + '/public/roles.js'); + loadInCtx(ctx, __dirname + '/public/app.js'); + loadInCtx(ctx, __dirname + '/public/nodes.js'); + const view = ctx.window._nodesMissingNodeView; + + await test('nodes.js exposes the missing-node view builder', async () => { + assert.strictEqual(typeof view, 'function'); + }); + + await test('inactive node: explains the state with name, role and last advert date', async () => { + const v = view(PK, NOT_FOUND); + assert.ok(v, 'expected a view for an inactive node'); + assert.ok(/No advert heard since/.test(v.html), 'missing "No advert heard since"'); + assert.ok(/this device is inactive/.test(v.html), 'missing "this device is inactive"'); + assert.ok(v.html.indexOf(ctx.formatAbsoluteTimestamp('2026-09-24T15:35:00Z')) !== -1, 'last advert date not shown'); + assert.ok(v.html.indexOf('Quiet Repeater') !== -1, 'inactive name missing'); + assert.ok(/repeater/i.test(v.html.replace('Quiet Repeater', '')), 'role missing'); + assert.ok(v.title.indexOf('Quiet Repeater') !== -1, 'title should name the device: ' + v.title); + assert.ok(!/Node not found/.test(v.html), 'must not dead-end on "Node not found"'); + }); + + await test('inactive observer: links to its observer page and back to Nodes', async () => { + const v = view(PK, NOT_FOUND); + assert.ok(v.html.indexOf('href="#/observers/' + encodeURIComponent(OBS_ID) + '"') !== -1, 'observer link missing'); + assert.ok(v.html.indexOf('href="#/nodes"') !== -1, 'Back to Nodes link missing'); + }); + + await test('observer without a node record: explains it and links the observer', async () => { + const v = view(PK, { error: 'Not found', observer: NOT_FOUND.observer }); + assert.ok(v, 'expected a view for an observer-only device'); + assert.ok(/no node record/i.test(v.html), 'missing "no node record" explanation'); + assert.ok(/no advert from it has been heard/i.test(v.html), 'explanation must say why: no advert heard'); + assert.ok(!/this device is inactive/.test(v.html), 'observer-only must not claim an inactive row'); + assert.ok(v.html.indexOf('Quiet Observer') !== -1, 'observer name missing'); + assert.ok(v.html.indexOf('href="#/observers/' + encodeURIComponent(OBS_ID) + '"') !== -1, 'observer link missing'); + }); + + await test('unknown key: no view, so the generic "Node not found" stays', async () => { + assert.strictEqual(view(PK, { error: 'Not found' }), null); + assert.strictEqual(view(PK, undefined), null); + assert.strictEqual(view(PK, null), null); + }); + + await test('node-controlled names and roles are escaped', async () => { + const evil = ''; + const v = view(PK, { + inactive_node: { public_key: PK, name: evil, role: evil, last_seen: '2026-09-24T15:35:00Z' }, + observer: { id: '">', name: evil, last_seen: '2026-10-04T04:23:00Z' }, + }); + assert.ok(v.html.indexOf(' in html'); + assert.ok(v.html.indexOf(' in html'); + }); + + console.log('\n' + passed + ' passed, ' + failed + ' failed'); + process.exit(failed ? 1 : 0); +})();