Test BGEN options stable across repeated opens

Each open of the streaming `.bgen` file spawns a fresh server-side
thread that constructs its own `BgenEncoder` via
`spec.encoder_factory(reader, opts)`. Pin that the options dataclass
(notably `--no-header-samples`) flows through every per-connection
encoder consistently — three sequential open/read/close cycles must
all return the same bytes, both at the `EncoderClient.open_stream`
layer and through a real FUSE mount.

Also exercise `--no-sample-file` / `--no-bgi` across three independent
`EncoderClient.start` cycles to confirm the handshake-time static-file
set is stable.

Author: jeromekelleher

tests/test_bgen_apps.py

@@ -8,6 +8,7 @@
 """
 
 import contextlib
+import dataclasses
 import errno
 import os
 import pathlib
@@ -88,14 +89,19 @@ async def _arun(cmd) -> None:
 
 
 @contextlib.asynccontextmanager
-async def _mount_bgen(tmp_path, vcz):
-    """Mount ``vcz`` as a BGEN fileset; yield ``(mnt, basename)``."""
+async def _mount_bgen(tmp_path, vcz, opts=None):
+    """Mount ``vcz`` as a BGEN fileset; yield ``(mnt, basename)``.
+
+    ``opts`` is the ``vcztools.ViewBgenOptions`` dataclass the
+    encoder-server runs under; defaults to a fresh ``ViewBgenOptions()``
+    (every field at its dataclass default).
+    """
     mnt = tmp_path / "mnt"
     mnt.mkdir()
     basename = vcz.path.stem
     sock_path = tmp_path / "bgen.sock"
     async with await encoder_client.EncoderClient.start(
-        str(vcz.path), sock_path, formats.BGEN_SPEC
+        str(vcz.path), sock_path, formats.BGEN_SPEC, opts=opts
     ) as client:
         ops = encoder_ops.EncoderOps(client, basename, formats.BGEN_SPEC)
         async with fuse_adapter.mount(ops, str(mnt)):
@@ -144,6 +150,39 @@ async def test_random_pread(self, fx_mounted_bgen):
             assert got == expected[off : off + size]
 
 
+class TestBgenOptionsAcrossOpens:
+    """Open the mounted ``.bgen`` repeatedly and verify the bytes are
+    invariant under the mount's options dataclass.
+
+    Each ``open()`` of the streaming file triggers a fresh FUSE ``open``
+    handler → fresh socket → fresh server-side thread that constructs
+    its own :class:`vcztools.BgenEncoder` via
+    ``spec.encoder_factory(reader, opts)``. The test pins that the
+    options dataclass flows through every per-connection encoder
+    consistently — e.g. ``--no-header-samples`` keeps producing the
+    same header-stripped bytes on the 2nd and 3rd read after open/close.
+    """
+
+    @pytest.mark.parametrize("no_header_samples", [True, False])
+    async def test_no_header_samples_stable_across_opens(
+        self, tmp_path, fx_small_vcz, no_header_samples
+    ):
+        opts = dataclasses.replace(
+            vcztools.ViewBgenOptions(), no_header_samples=no_header_samples
+        )
+        ref_reader = opts.make_reader(str(fx_small_vcz.path))
+        with vcztools.BgenEncoder(
+            ref_reader, embed_header_samples=not no_header_samples
+        ) as ref:
+            expected = ref.read(0, ref.total_size)
+
+        async with _mount_bgen(tmp_path, fx_small_vcz, opts=opts) as (mnt, basename):
+            bgen_path = mnt / f"{basename}.bgen"
+            for cycle in range(3):
+                data = await trio.to_thread.run_sync(bgen_path.read_bytes)
+                assert data == expected, f"cycle {cycle} differed from reference"
+
+
 def _pread_sync(path: pathlib.Path, off: int, size: int) -> bytes:
     with path.open("rb") as f:
         f.seek(off)

tests/test_encoder_client.py

@@ -424,6 +424,78 @@ async def test_max_alleles_filter_through_start(
         assert not client._proc.is_alive()
         assert client._proc.exitcode == 0
 
+    @pytest.mark.parametrize("no_header_samples", [True, False])
+    async def test_bgen_no_header_samples_stable_across_opens(
+        self, fx_small_vcz, tmp_path, no_header_samples
+    ):
+        """``--no-header-samples`` flows into every per-connection
+        ``BgenEncoder`` consistently.
+
+        Each ``open_stream`` spawns a fresh server-side thread that
+        constructs a new encoder via ``spec.encoder_factory(reader, opts)``.
+        Three sequential open/read/close cycles must all return the same
+        bytes — and those bytes must match an in-process reference
+        ``BgenEncoder`` constructed with the matching
+        ``embed_header_samples`` flag.
+        """
+        opts = dataclasses.replace(
+            vcztools.ViewBgenOptions(), no_header_samples=no_header_samples
+        )
+        ref_reader = opts.make_reader(str(fx_small_vcz.path))
+        with vcztools.BgenEncoder(
+            ref_reader, embed_header_samples=not no_header_samples
+        ) as ref:
+            expected_size = int(ref.total_size)
+            expected = ref.read(0, expected_size)
+
+        socket_path = tmp_path / "encoder.sock"
+        async with await encoder_client.EncoderClient.start(
+            str(fx_small_vcz.path), socket_path, formats.BGEN_SPEC, opts=opts
+        ) as client:
+            assert client.stream_size == expected_size
+            for cycle in range(3):
+                conn = await client.open_stream()
+                try:
+                    data = await conn.read(0, client.stream_size)
+                finally:
+                    await conn.aclose()
+                assert data == expected, f"cycle {cycle} differed from reference"
+
+    @pytest.mark.parametrize(
+        ("no_sample_file", "no_bgi"),
+        [(True, False), (False, True), (True, True), (False, False)],
+    )
+    async def test_bgen_sidecar_toggles_stable_across_starts(
+        self, fx_small_vcz, tmp_path, no_sample_file, no_bgi
+    ):
+        """The handshake's ``static_files`` honours ``--no-sample-file``
+        / ``--no-bgi`` and yields the same suffix set on each
+        ``EncoderClient.start`` against the same options."""
+        opts = dataclasses.replace(
+            vcztools.ViewBgenOptions(),
+            no_sample_file=no_sample_file,
+            no_bgi=no_bgi,
+        )
+        expected_suffixes = formats.BGEN_SPEC.static_suffixes(opts)
+        first: dict[str, bytes] | None = None
+        for cycle in range(3):
+            socket_path = tmp_path / f"encoder-{cycle}.sock"
+            async with await encoder_client.EncoderClient.start(
+                str(fx_small_vcz.path), socket_path, formats.BGEN_SPEC, opts=opts
+            ) as client:
+                assert tuple(client.static_files) == expected_suffixes
+                # ``.bgen.bgi`` SQLite payloads have non-deterministic
+                # header bytes across independent writes; compare sizes
+                # only for that entry and the full body for ``.sample``.
+                if first is None:
+                    first = dict(client.static_files)
+                    continue
+                for suffix, body in client.static_files.items():
+                    if suffix == ".bgen.bgi":
+                        assert len(body) == len(first[suffix])
+                    else:
+                        assert body == first[suffix]
+
     @pytest.mark.parametrize(
         "spec", [formats.PLINK_SPEC, formats.BGEN_SPEC], ids=["plink", "bgen"]
     )