4 files changed, 430 insertions, 3 deletions
diff --git a/packages/meshbay-node/tests/test_chat_store.py b/packages/meshbay-node/tests/test_chat_store.py
new file mode 100644
index 0000000..d74310d
--- /dev/null
+++ b/packages/meshbay-node/tests/test_chat_store.py
@@ -0,0 +1,91 @@
+"""
+Tests for the SQLite-backed chat message store.
+"""
+
+import pytest
+import pytest_asyncio
+from pathlib import Path
+
+from meshbay_node.chat.store import ChatStore
+
+
+@pytest_asyncio.fixture
+async def store(tmp_path):
+    s = ChatStore(db_path=tmp_path / "test_chat.db")
+    await s.open()
+    yield s
+    await s.close()
+
+
+@pytest.mark.asyncio
+async def test_save_and_retrieve(store):
+    row_id = await store.save_message(
+        sender_id="alice", iteration=0, payload=b"hello",
+    )
+    assert row_id == 1
+
+    msgs = await store.get_messages()
+    assert len(msgs) == 1
+    assert msgs[0].sender_id == "alice"
+    assert msgs[0].iteration == 0
+    assert msgs[0].payload == b"hello"
+    assert msgs[0].thread_id is None
+
+
+@pytest.mark.asyncio
+async def test_message_count(store):
+    assert await store.message_count() == 0
+    await store.save_message("alice", 0, b"msg1")
+    await store.save_message("bob", 1, b"msg2")
+    assert await store.message_count() == 2
+
+
+@pytest.mark.asyncio
+async def test_get_messages_since(store):
+    await store.save_message("alice", 0, b"old")
+    all_msgs = await store.get_messages()
+    cutoff = all_msgs[0].timestamp
+    await store.save_message("bob", 1, b"new")
+
+    msgs = await store.get_messages(since=cutoff)
+    assert len(msgs) == 1
+    assert msgs[0].sender_id == "bob"
+
+
+@pytest.mark.asyncio
+async def test_thread_messages(store):
+    await store.save_message("alice", 0, b"root", thread_id="t1")
+    await store.save_message("bob", 1, b"reply", thread_id="t1")
+    await store.save_message("carol", 2, b"other")
+
+    thread = await store.get_thread("t1")
+    assert len(thread) == 2
+    assert thread[0].sender_id == "alice"
+    assert thread[1].sender_id == "bob"
+
+
+@pytest.mark.asyncio
+async def test_message_ordering(store):
+    for i in range(5):
+        await store.save_message(f"user-{i}", i, f"msg-{i}".encode())
+
+    msgs = await store.get_messages()
+    assert len(msgs) == 5
+    for i, m in enumerate(msgs):
+        assert m.sender_id == f"user-{i}"
+
+
+@pytest.mark.asyncio
+async def test_limit(store):
+    for i in range(10):
+        await store.save_message("alice", i, f"msg-{i}".encode())
+
+    msgs = await store.get_messages(limit=3)
+    assert len(msgs) == 3
+
+
+@pytest.mark.asyncio
+async def test_context_manager(tmp_path):
+    async with ChatStore(db_path=tmp_path / "ctx_test.db") as store:
+        await store.save_message("alice", 0, b"test")
+        assert await store.message_count() == 1
diff --git a/packages/meshbay-node/tests/test_multi_group.py b/packages/meshbay-node/tests/test_multi_group.py
new file mode 100644
index 0000000..9be8d47
--- /dev/null
+++ b/packages/meshbay-node/tests/test_multi_group.py
@@ -0,0 +1,169 @@
+"""
+Multi-group isolation test: two groups on one QUIC server.
+
+Verifies that:
+  - A user in group-a can fetch files from group-a
+  - A user in group-a is rejected when requesting group-b
+  - A user in both groups can access both
+"""
+
+import os
+import time
+import jwt
+import pytest
+from pathlib import Path
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+from cryptography.hazmat.primitives import serialization
+
+from meshbay_common.crypto import generate_gek, pk_to_b64
+from meshbay_node.indexer import DirectoryIndexer, GroupIndex
+from meshbay_node.transport.quic_server import QuicChunkServer
+from meshbay_node.transport.quic_client import QuicChunkClient
+
+
+@pytest.fixture
+def sk_node():
+    return Ed25519PrivateKey.generate()
+
+@pytest.fixture
+def sk_hub():
+    return Ed25519PrivateKey.generate()
+
+@pytest.fixture
+def gek_a():
+    return generate_gek()
+
+@pytest.fixture
+def gek_b():
+    return generate_gek()
+
+@pytest.fixture
+def dir_a(tmp_path):
+    d = tmp_path / "group_a"
+    d.mkdir()
+    (d / "file_a.txt").write_bytes(b"content from group A " * 100)
+    return d
+
+@pytest.fixture
+def dir_b(tmp_path):
+    d = tmp_path / "group_b"
+    d.mkdir()
+    (d / "file_b.txt").write_bytes(b"content from group B " * 100)
+    return d
+
+
+def make_jwt(sk_hub, pk_node_b64, groups, user_id="user-001", ttl=3600):
+    sk_pem = sk_hub.private_bytes(
+        serialization.Encoding.PEM,
+        serialization.PrivateFormat.PKCS8,
+        serialization.NoEncryption(),
+    )
+    now = int(time.time())
+    return jwt.encode({
+        "iss": "test-hub", "sub": user_id,
+        "pk_user": pk_node_b64, "hub_id": "test-hub",
+        "jti": "test-jti", "iat": now, "exp": now + ttl,
+        "groups": groups,
+    }, sk_pem, algorithm="EdDSA")
+
+
+@pytest.fixture
+async def multi_group_server(sk_node, sk_hub, gek_a, gek_b, dir_a, dir_b, tmp_path):
+    hub_pk_pem = sk_hub.public_key().public_bytes(
+        serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)
+
+    indexer_a = DirectoryIndexer(root=dir_a, group_id="group-a", sk_node=sk_node, gek=gek_a)
+    await indexer_a.initial_scan()
+
+    indexer_b = DirectoryIndexer(root=dir_b, group_id="group-b", sk_node=sk_node, gek=gek_b)
+    await indexer_b.initial_scan()
+
+    groups = {
+        "group-a": {"gek": gek_a, "shared_root": dir_a, "index": indexer_a.index},
+        "group-b": {"gek": gek_b, "shared_root": dir_b, "index": indexer_b.index},
+    }
+
+    cert_path = tmp_path / "node.crt"
+    key_path  = tmp_path / "node.key"
+
+    server = QuicChunkServer(
+        sk_node=sk_node, hub_pk_pem=hub_pk_pem,
+        gek=gek_a, shared_root=dir_a, index=indexer_a.index,
+        host="127.0.0.1", port=19200,
+        cert_path=cert_path, key_path=key_path,
+        groups=groups,
+    )
+    await server.start()
+    yield server, indexer_a, indexer_b
+    await server.stop()
+
+
+@pytest.mark.asyncio
+async def test_user_can_access_own_group(
+    multi_group_server, sk_node, sk_hub, gek_a,
+):
+    """User in group-a can fetch index and chunks from group-a."""
+    server, indexer_a, _ = multi_group_server
+    token = make_jwt(sk_hub, pk_to_b64(sk_node.public_key()), groups=["group-a"])
+
+    async with QuicChunkClient(
+        host="127.0.0.1", port=19200,
+        jwt_token=token, gek=gek_a,
+        pk_node_b64=pk_to_b64(sk_node.public_key()),
+        group_id="group-a",
+    ) as client:
+        wire = await client.fetch_index()
+        recovered = GroupIndex.deserialize(wire, sk_node=sk_node, gek=gek_a)
+        assert recovered.count == 1
+
+        entry = recovered.entries[0]
+        assert entry.name == "file_a.txt"
+        chunk = await client.fetch_chunk(entry.id, chunk_index=0)
+        assert chunk == b"content from group A " * 100
+
+
+@pytest.mark.asyncio
+async def test_user_rejected_from_other_group(
+    multi_group_server, sk_node, sk_hub, gek_b,
+):
+    """User in group-a only is rejected when requesting group-b."""
+    server, _, _ = multi_group_server
+    token = make_jwt(sk_hub, pk_to_b64(sk_node.public_key()), groups=["group-a"])
+
+    with pytest.raises(ConnectionError, match="rejected"):
+        async with QuicChunkClient(
+            host="127.0.0.1", port=19200,
+            jwt_token=token, gek=gek_b,
+            pk_node_b64=pk_to_b64(sk_node.public_key()),
+            group_id="group-b",
+        ) as client:
+            await client.fetch_index()
+
+
+@pytest.mark.asyncio
+async def test_dual_group_user_accesses_both(
+    multi_group_server, sk_node, sk_hub, gek_a, gek_b,
+):
+    """User in both groups can access either group's files."""
+    server, indexer_a, indexer_b = multi_group_server
+    token = make_jwt(sk_hub, pk_to_b64(sk_node.public_key()), groups=["group-a", "group-b"])
+
+    async with QuicChunkClient(
+        host="127.0.0.1", port=19200,
+        jwt_token=token, gek=gek_a,
+        pk_node_b64=pk_to_b64(sk_node.public_key()),
+        group_id="group-a",
+    ) as client_a:
+        wire_a = await client_a.fetch_index()
+        idx_a = GroupIndex.deserialize(wire_a, sk_node=sk_node, gek=gek_a)
+        assert idx_a.entries[0].name == "file_a.txt"
+
+    async with QuicChunkClient(
+        host="127.0.0.1", port=19200,
+        jwt_token=token, gek=gek_b,
+        pk_node_b64=pk_to_b64(sk_node.public_key()),
+        group_id="group-b",
+    ) as client_b:
+        wire_b = await client_b.fetch_index()
+        idx_b = GroupIndex.deserialize(wire_b, sk_node=sk_node, gek=gek_b)
+        assert idx_b.entries[0].name == "file_b.txt"
diff --git a/packages/meshbay-node/tests/test_quic_transport.py b/packages/meshbay-node/tests/test_quic_transport.py
index 2abd465..0c1a1cd 100644
--- a/packages/meshbay-node/tests/test_quic_transport.py
+++ b/packages/meshbay-node/tests/test_quic_transport.py
@@ -14,7 +14,7 @@ from cryptography.hazmat.primitives import serialization
 
 from meshbay_common.crypto import generate_gek, pk_to_b64
 from meshbay_node.indexer import DirectoryIndexer, GroupIndex
-from meshbay_node.transport.quic_server import QuicChunkServer
+from meshbay_node.transport.quic_server import QuicChunkServer, Denylist
 from meshbay_node.transport.quic_client import QuicChunkClient
 
 
@@ -38,7 +38,7 @@ def shared_dir(tmp_path):
     (d / "small.txt").write_bytes(b"hello quic " * 100)
     return d
 
-def make_jwt(sk_hub, pk_node_b64, ttl=3600):
+def make_jwt(sk_hub, pk_node_b64, ttl=3600, groups=None):
     sk_pem = sk_hub.private_bytes(
         serialization.Encoding.PEM,
         serialization.PrivateFormat.PKCS8,
@@ -49,6 +49,7 @@ def make_jwt(sk_hub, pk_node_b64, ttl=3600):
         "iss": "test-hub", "sub": "user-001",
         "pk_user": pk_node_b64, "hub_id": "test-hub",
         "jti": "test-jti", "iat": now, "exp": now + ttl,
+        "groups": groups or [],
     }, sk_pem, algorithm="EdDSA")
 
 
@@ -155,3 +156,132 @@ async def test_quic_invalid_jwt_rejected(sk_node, sk_hub, gek, shared_dir, tmp_p
             await client.fetch_index()
 
     await server.stop()
+
+
+@pytest.mark.asyncio
+async def test_quic_wrong_group_rejected(sk_node, sk_hub, gek, shared_dir, tmp_path):
+    """QUIC server rejects a client whose JWT groups don't include the requested group_id."""
+    hub_pk_pem = sk_hub.public_key().public_bytes(
+        serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)
+
+    indexer = DirectoryIndexer(root=shared_dir, group_id="g", sk_node=sk_node, gek=gek)
+    await indexer.initial_scan()
+
+    cert_path = tmp_path / "node.crt"
+    key_path  = tmp_path / "node.key"
+
+    server = QuicChunkServer(
+        sk_node=sk_node, hub_pk_pem=hub_pk_pem, gek=gek,
+        shared_root=shared_dir, index=indexer.index,
+        host="127.0.0.1", port=19103,
+        cert_path=cert_path, key_path=key_path,
+    )
+    await server.start()
+
+    token = make_jwt(sk_hub, pk_to_b64(sk_node.public_key()), groups=["group-a"])
+
+    with pytest.raises(ConnectionError, match="rejected"):
+        async with QuicChunkClient(
+            host="127.0.0.1", port=19103,
+            jwt_token=token, gek=gek,
+            pk_node_b64=pk_to_b64(sk_node.public_key()),
+            group_id="group-b",
+        ) as client:
+            await client.fetch_index()
+
+    await server.stop()
+
+
+@pytest.mark.asyncio
+async def test_quic_session_resumption(sk_node, sk_hub, gek, shared_dir, tmp_path):
+    """QUIC 0-RTT: connect, save session ticket, reconnect with ticket."""
+    hub_pk_pem = sk_hub.public_key().public_bytes(
+        serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)
+
+    indexer = DirectoryIndexer(root=shared_dir, group_id="g", sk_node=sk_node, gek=gek)
+    await indexer.initial_scan()
+
+    cert_path = tmp_path / "node.crt"
+    key_path  = tmp_path / "node.key"
+
+    server = QuicChunkServer(
+        sk_node=sk_node, hub_pk_pem=hub_pk_pem, gek=gek,
+        shared_root=shared_dir, index=indexer.index,
+        host="127.0.0.1", port=19104,
+        cert_path=cert_path, key_path=key_path,
+    )
+    await server.start()
+
+    token = make_jwt(sk_hub, pk_to_b64(sk_node.public_key()))
+    pk_b64 = pk_to_b64(sk_node.public_key())
+
+    # First connection — captures session ticket
+    saved_ticket = None
+    async with QuicChunkClient(
+        host="127.0.0.1", port=19104,
+        jwt_token=token, gek=gek, pk_node_b64=pk_b64,
+    ) as client:
+        wire = await client.fetch_index()
+        assert GroupIndex.deserialize(wire, sk_node=sk_node, gek=gek).count == 2
+        saved_ticket = client.session_ticket
+
+    # Allow server to process the close
+    await asyncio.sleep(0.1)
+
+    # Second connection — reuses session ticket (0-RTT)
+    async with QuicChunkClient(
+        host="127.0.0.1", port=19104,
+        jwt_token=token, gek=gek, pk_node_b64=pk_b64,
+        session_ticket=saved_ticket,
+    ) as client:
+        wire = await client.fetch_index()
+        assert GroupIndex.deserialize(wire, sk_node=sk_node, gek=gek).count == 2
+
+    await server.stop()
+
+
+@pytest.mark.asyncio
+async def test_quic_denylist_blocks_user(sk_node, sk_hub, gek, shared_dir, tmp_path):
+    """QUIC server rejects a connection when the user is on the denylist."""
+    hub_pk_pem = sk_hub.public_key().public_bytes(
+        serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)
+
+    indexer = DirectoryIndexer(root=shared_dir, group_id="g", sk_node=sk_node, gek=gek)
+    await indexer.initial_scan()
+
+    cert_path = tmp_path / "node.crt"
+    key_path  = tmp_path / "node.key"
+
+    denylist = Denylist()
+    server = QuicChunkServer(
+        sk_node=sk_node, hub_pk_pem=hub_pk_pem, gek=gek,
+        shared_root=shared_dir, index=indexer.index,
+        host="127.0.0.1", port=19105,
+        cert_path=cert_path, key_path=key_path,
+        denylist=denylist,
+    )
+    await server.start()
+
+    token = make_jwt(sk_hub, pk_to_b64(sk_node.public_key()))
+    pk_b64 = pk_to_b64(sk_node.public_key())
+
+    # Connection works before denylisting
+    async with QuicChunkClient(
+        host="127.0.0.1", port=19105,
+        jwt_token=token, gek=gek, pk_node_b64=pk_b64,
+    ) as client:
+        wire = await client.fetch_index()
+        assert GroupIndex.deserialize(wire, sk_node=sk_node, gek=gek).count == 2
+
+    # Add user to denylist
+    denylist.deny_user("user-001")
+
+    # Connection now rejected
+    with pytest.raises(Exception):
+        async with QuicChunkClient(
+            host="127.0.0.1", port=19105,
+            jwt_token=token, gek=gek, pk_node_b64=pk_b64,
+        ) as client:
+            await client.fetch_index()
+
+    await server.stop()
diff --git a/packages/meshbay-node/tests/test_transport.py b/packages/meshbay-node/tests/test_transport.py
index 2064ba5..0e70d72 100644
--- a/packages/meshbay-node/tests/test_transport.py
+++ b/packages/meshbay-node/tests/test_transport.py
@@ -41,7 +41,7 @@ def shared_dir(tmp_path):
     (d / "small.txt").write_bytes(b"hello meshbay " * 100)
     return d
 
-def make_jwt(sk_hub, pk_node_b64, user_id="user-001", ttl=3600):
+def make_jwt(sk_hub, pk_node_b64, user_id="user-001", ttl=3600, groups=None):
     sk_pem = sk_hub.private_bytes(
         serialization.Encoding.PEM,
         serialization.PrivateFormat.PKCS8,
@@ -53,6 +53,7 @@ def make_jwt(sk_hub, pk_node_b64, user_id="user-001", ttl=3600):
         "pk_user": pk_node_b64, "hub_id": "test-hub",
         "jti": "test-jti",
         "iat": now, "exp": now + ttl,
+        "groups": groups or [],
     }, sk_pem, algorithm="EdDSA")
 
 
@@ -154,6 +155,42 @@ async def test_invalid_jwt_rejected(sk_node, sk_hub, gek, shared_dir, tmp_path):
 
 
 @pytest.mark.asyncio
+async def test_wrong_group_rejected(sk_node, sk_hub, gek, shared_dir, tmp_path):
+    """TCP+TLS server rejects a client whose JWT groups don't include the requested group_id."""
+    hub_pk_pem = sk_hub.public_key().public_bytes(
+        serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)
+
+    indexer = DirectoryIndexer(root=shared_dir, group_id="g",
+                               sk_node=sk_node, gek=gek)
+    await indexer.initial_scan()
+
+    cert_path = tmp_path / "node.crt"
+    key_path  = tmp_path / "node.key"
+
+    server = ChunkServer(
+        sk_node=sk_node, hub_pk_pem=hub_pk_pem, gek=gek,
+        shared_root=shared_dir, index=indexer.index,
+        host="127.0.0.1", port=0,
+        cert_path=cert_path, key_path=key_path,
+    )
+    await server.start()
+    port = server._server.sockets[0].getsockname()[1]
+
+    token = make_jwt(sk_hub, pk_to_b64(sk_node.public_key()), groups=["group-a"])
+
+    with pytest.raises(ConnectionError, match="rejected"):
+        async with ChunkClient(
+            host="127.0.0.1", port=port,
+            jwt_token=token, gek=gek,
+            pk_node_b64=pk_to_b64(sk_node.public_key()),
+            group_id="group-b",
+        ) as client:
+            pass
+
+    await server.stop()
+
+
+@pytest.mark.asyncio
 async def test_fetch_index(sk_node, sk_hub, gek, shared_dir, tmp_path):
     hub_pk_pem = sk_hub.public_key().public_bytes(
         serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)