Re- enabling disabled temporal tests as pytest: t.vect.observe.strds

[sakirr05]

Hey maintainers,

I came across testsuite/test.t.vect.observe.strds.layer_bug.sh and noticed it's been disabled — line 7 is just exit:

The test created 270 maps to check layer limits but never actually asserted
anything. It just ran commands and moved on:

t.vect.observe.strds input=prec strds=precip_abs1 output=prec_observer vector=prec_observer column="test_val"
v.info prec_observer
t.info type=stvds input=prec_observer
# no assertions anywhere

I rewrote it as pytest with 50 maps instead of 270 (enough to hit the 32/64 layer thresholds) and added actual assertions. Here's the gist:
Fixtures create isolated projects so nothing leaks between tests:

@pytest.fixture(scope="module")
def simple_observation_session(tmp_path_factory):
    tmp_path = tmp_path_factory.mktemp("observe_strds_simple")
    project = tmp_path / "test"
    _create_project(project)
    with _init_session(project) as session:
        session_env = _session_env(session)
        gs.run_command("g.region", s=0, n=80, w=0, e=120,
                       b=0, t=50, res=10, res3=10, env=session_env)
        raster_names = []
        for i in range(1, 7):
            name = f"prec_{i}"
            gs.mapcalc(f"{name} = {i * 100.0}", env=session_env)
            raster_names.append(name)
        gs.run_command("v.random", output="obs_points", npoints=5,
                       seed=1, env=session_env)
        gs.run_command("t.create", type="strds", temporaltype="absolute",
                       output="precip", title="Precipitation",
                       description="Test STRDS", env=session_env)
        gs.run_command("t.register", type="raster", flags="i",
                       input="precip", maps=",".join(raster_names),
                       start="2001-01-01", increment="1 month", env=session_env)
        yield SimpleNamespace(
            session=session, env=session_env, strds_name="precip",
            vector_name="obs_points", raster_names=raster_names, n_maps=6,
        )

Basic tests verify the module actually produces correct output:

def test_single_strds_observation(self, simple_observation_session):
    data = simple_observation_session
    gs.run_command("t.vect.observe.strds", input=data.vector_name,
                   strds=data.strds_name, output="basic_stvds",
                   vector_output="basic_vec", columns="obs",
                   env=data.env, overwrite=True)
    info = gs.parse_command("t.info", type="stvds",
                            input="basic_stvds", flags="g", env=data.env)
    assert int(info["number_of_maps"]) == data.n_maps

def test_observation_values_present(self, simple_observation_session):
    data = simple_observation_session
    # ... run t.vect.observe.strds ...
    rows = gs.read_command("v.db.select", map="vals_vec", layer=1,
                           columns="sampled", flags="c", env=data.env)
    values = [float(v) for v in rows.strip().splitlines() if v.strip()]
    assert all(v == pytest.approx(100.0) for v in values)

Error handling — stuff the shell tests never checked:

def test_missing_input_vector_fails(self, simple_observation_session):
    ret = gs.run_command("t.vect.observe.strds", input="nonexistent_vector",
                         strds=data.strds_name, output="err_stvds",
                         vector_output="err_vec", columns="x",
                         env=data.env, errors="status")
    assert ret != 0

def test_column_count_mismatch_fails(self, simple_observation_session):
    # Two columns but one STRDS — should fail
    ret = gs.run_command("t.vect.observe.strds", input=data.vector_name,
                         strds=data.strds_name, output="err_stvds",
                         vector_output="err_vec", columns="a,b",
                         env=data.env, errors="status")
    assert ret != 0

Layer-limit tests (the re-enabled part, marked @pytest.mark.slow):

@pytest.mark.slow
class TestLayerLimits:
    def test_many_layers_observation_succeeds(self, large_observation_session):
        data = large_observation_session
        gs.run_command("t.vect.observe.strds", input=data.vector_name,
                       strds=data.strds_name, output="large_stvds",
                       vector_output="large_vec", columns="lval",
                       env=data.env, overwrite=True)
        info = gs.parse_command("t.info", type="stvds",
                                input="large_stvds", flags="g", env=data.env)
        assert int(info["number_of_maps"]) == data.n_maps  # 50

    def test_many_layers_data_values(self, large_observation_session):
        for layer_num in (1, 10, 25, data.n_maps):
            rows = gs.read_command("v.db.select", map="large_vec",
                                   layer=layer_num, columns="lval",
                                   flags="c", env=data.env)
            values = [v.strip() for v in rows.strip().splitlines() if v.strip()]
            numeric = [v for v in values if v not in {"", "*"}]
            assert len(numeric) > 0, f"Layer {layer_num}: all values are NULL"

All 9 tests pass (~3.5 min total):

Linting clean:

Questions

Before I open a PR
I wanted to check with you all first is this change needed right or no?

1. Does it make sense to add tests/ (pytest) alongside the existing testsuite/ (shell) for this module?
2. Is 50 maps a reasonable number or would you prefer something different?
3. I noticed other disabled tests in the temporal suite worth auditing those systematically?