socketduct 0.1.25 → 0.1.26

package/test/unit/sessions/session.test.js

@@ -1,5 +1,4 @@
-import assert from "node:assert/strict"
-import test from "node:test"
+import {describe, expect, it} from "@velocious/testing"
 
 import {
   createSession,
@@ -8,77 +7,64 @@ import {
   SessionStore
 } from "../../../src/sessions/session.js"
 
-test("createSession creates a named creating session with an opaque identifier", () => {
-  const session = createSession({name: "Office link", ownerId: "user-1", target: {host: "127.0.0.1", port: 22}})
+describe("session store", () => {
+  it("createSession creates a named creating session with an opaque identifier", () => {
+    const session = createSession({name: "Office link", ownerId: "user-1", target: {host: "127.0.0.1", port: 22}})
 
-  assert.equal(session.name, "Office link")
-  assert.equal(session.ownerId, "user-1")
-  assert.equal(session.state, "creating")
-  assert.match(session.identifier, /^[a-zA-Z0-9_-]{32,}$/)
-  assert.equal(session.clientSequence, 0)
-  assert.equal(session.relaySequence, 0)
-  assert.deepEqual(session.target, {host: "127.0.0.1", port: 22})
-})
+    expect(session.name).toBe("Office link")
+    expect(session.ownerId).toBe("user-1")
+    expect(session.state).toBe("creating")
+    expect(session.identifier).toMatch(/^[a-zA-Z0-9_-]{32,}$/)
+    expect(session.clientSequence).toBe(0)
+    expect(session.relaySequence).toBe(0)
+    expect(session.target).toEqual({host: "127.0.0.1", port: 22})
+  })
 
-test("transitionSession only allows legal lifecycle transitions", () => {
-  const session = createSession({name: "Flaky line", ownerId: "user-1", target: {host: "127.0.0.1", port: 22}, identifier: "session_123456789012345678901234567890"})
+  it("transitionSession only allows legal lifecycle transitions", () => {
+    const session = createSession({name: "Flaky line", ownerId: "user-1", target: {host: "127.0.0.1", port: 22}, identifier: "session_123456789012345678901234567890"})
 
-  assert.equal(transitionSession(session, "active").state, "active")
-  assert.equal(transitionSession({...session, state: "interrupted"}, "resuming").state, "resuming")
-  assert.equal(transitionSession({...session, state: "resuming"}, "active").state, "active")
+    expect(transitionSession(session, "active").state).toBe("active")
+    expect(transitionSession({...session, state: "interrupted"}, "resuming").state).toBe("resuming")
+    expect(transitionSession({...session, state: "resuming"}, "active").state).toBe("active")
 
-  assert.throws(
-    () => transitionSession({...session, state: "active"}, "resuming"),
-    /illegal session state transition/i
-  )
-})
+    expect(() => transitionSession({...session, state: "active"}, "resuming")).toThrow(/illegal session state transition/i)
+  })
 
-test("SessionStore resumes sessions by identifier for the owning user", () => {
-  const store = new SessionStore()
-  const session = store.create({name: "Müggelheim relay", ownerId: "kasper", target: {host: "127.0.0.1", port: 22}})
-  store.transition(session.identifier, "active")
-  store.transition(session.identifier, "interrupted")
+  it("SessionStore resumes sessions by identifier for the owning user", () => {
+    const store = new SessionStore()
+    const session = store.create({name: "Müggelheim relay", ownerId: "kasper", target: {host: "127.0.0.1", port: 22}})
+    store.transition(session.identifier, "active")
+    store.transition(session.identifier, "interrupted")
 
-  const resumed = resumeSession(store, {
-    identifier: session.identifier,
-    ownerId: "kasper"
-  })
+    const resumed = resumeSession(store, {
+      identifier: session.identifier,
+      ownerId: "kasper"
+    })
 
-  assert.equal(resumed.identifier, session.identifier)
-  assert.equal(resumed.state, "resuming")
-})
+    expect(resumed.identifier).toBe(session.identifier)
+    expect(resumed.state).toBe("resuming")
+  })
 
-test("SessionStore rejects resume for a missing or expired session", () => {
-  const store = new SessionStore({now: () => 2_000})
-  store.create({name: "Expired", ownerId: "user-1", target: {host: "127.0.0.1", port: 22}, identifier: "expired_session_12345678901234567890", expiresAt: 1_000})
+  it("SessionStore rejects resume for a missing or expired session", () => {
+    const store = new SessionStore({now: () => 2_000})
+    store.create({name: "Expired", ownerId: "user-1", target: {host: "127.0.0.1", port: 22}, identifier: "expired_session_12345678901234567890", expiresAt: 1_000})
 
-  assert.throws(
-    () => resumeSession(store, {identifier: "missing_session_12345678901234567890", ownerId: "user-1"}),
-    /not found/i
-  )
-  assert.throws(
-    () => resumeSession(store, {identifier: "expired_session_12345678901234567890", ownerId: "user-1"}),
-    /expired/i
-  )
-})
+    expect(() => resumeSession(store, {identifier: "missing_session_12345678901234567890", ownerId: "user-1"})).toThrow(/not found/i)
+    expect(() => resumeSession(store, {identifier: "expired_session_12345678901234567890", ownerId: "user-1"})).toThrow(/expired/i)
+  })
 
-test("SessionStore rejects resume while initial target acquisition is still creating", () => {
-  const store = new SessionStore()
-  const session = store.create({name: "Pending", ownerId: "user-1", target: {host: "127.0.0.1", port: 22}})
+  it("SessionStore rejects resume while initial target acquisition is still creating", () => {
+    const store = new SessionStore()
+    const session = store.create({name: "Pending", ownerId: "user-1", target: {host: "127.0.0.1", port: 22}})
 
-  assert.throws(
-    () => resumeSession(store, {identifier: session.identifier, ownerId: "user-1"}),
-    /not resumable/i
-  )
-  assert.equal(store.get(session.identifier)?.state, "creating")
-})
+    expect(() => resumeSession(store, {identifier: session.identifier, ownerId: "user-1"})).toThrow(/not resumable/i)
+    expect(store.get(session.identifier)?.state).toBe("creating")
+  })
 
-test("SessionStore prevents a different user from resuming a session", () => {
-  const store = new SessionStore()
-  const session = store.create({name: "Private", ownerId: "owner", target: {host: "127.0.0.1", port: 22}})
+  it("SessionStore prevents a different user from resuming a session", () => {
+    const store = new SessionStore()
+    const session = store.create({name: "Private", ownerId: "owner", target: {host: "127.0.0.1", port: 22}})
 
-  assert.throws(
-    () => resumeSession(store, {identifier: session.identifier, ownerId: "other-user"}),
-    /does not belong/i
-  )
+    expect(() => resumeSession(store, {identifier: session.identifier, ownerId: "other-user"})).toThrow(/does not belong/i)
+  })
 })