Reapply "Improve study_database robustness and add comprehensive tests"

This reverts commit da33750.

Author: TimSlendebroek

src/studies/study_database.jl

@@ -321,7 +321,7 @@ function save_study_database(h5path::AbstractString, db::study_database; kw...)
         # If :gparent column doesn't exist, create it from item names
         parent_groups = String[]
         for (i, item) in pairs(db.items)
-            if !isnothing(item.name)
+            if !isnothing(item.name) && !isempty(item.name)
                 push!(parent_groups, IMAS.norm_hdf5_path(item.name))
             else
                 Lpad = length(string(length(db.items)))
@@ -344,7 +344,7 @@ function save_study_database(h5path::AbstractString, db::study_database; kw...)
             if ismissing(pg) || !isa(pg, AbstractString) || isempty(pg)
                 # Generate auto name for empty/missing values
                 item = db.items[i]
-                if !isnothing(item.name)
+                if !isnothing(item.name) && !isempty(item.name)
                     push!(updated_parent_groups, IMAS.norm_hdf5_path(item.name))
                 else
                     auto_item_name = "/item" * lpad(i, Lpad, "0")

test/runtests_study_database.jl

@@ -167,4 +167,121 @@ using FUSE.DataFrames
         end
         # mktempdir do ... end ensures temporary dir cleanup automatically
     end
+
+    @testset "Edge cases - empty names and :gparent handling" begin
+        # Test items with nothing/empty names
+        dd_test = FUSE.IMAS.json2imas(joinpath(@__DIR__, "..", "sample", "CAT_eq_ods.json"))
+
+        # Create items with various name states
+        item_with_name = FUSE.study_database_item(name="valid_name", dd=deepcopy(dd_test))
+        item_nothing_name = FUSE.study_database_item(name=nothing, dd=deepcopy(dd_test))
+        item_empty_name = FUSE.study_database_item(name="", dd=deepcopy(dd_test))
+
+        # Test 1: DataFrame without :gparent column (should auto-create)
+        @testset "Missing :gparent column" begin
+            df_no_gparent = DataFrame(
+                case = [1, 2, 3],
+                status = ["success", "fail", "success"]
+            )
+            items_test = [item_with_name, item_nothing_name, item_empty_name]
+            db_no_gparent = FUSE.study_database(df_no_gparent, items_test)
+
+            mktempdir() do save_dir
+                h5file = joinpath(save_dir, "test_no_gparent.h5")
+                # This should auto-create :gparent column
+                FUSE.save_study_database(h5file, db_no_gparent; timer=false)
+
+                # Verify :gparent was created
+                @test hasproperty(db_no_gparent.df, :gparent)
+                @test db_no_gparent.df.gparent[1] == "/valid_name"
+                @test db_no_gparent.df.gparent[2] == "/item2"  # auto-generated
+                @test db_no_gparent.df.gparent[3] == "/item3"  # auto-generated
+            end
+        end
+
+        # Test 2: DataFrame with invalid :gparent values
+        @testset "Invalid :gparent values" begin
+            df_bad_gparent = DataFrame(
+                gparent = ["valid/path", missing, ""],  # mixed valid/invalid
+                case = [1, 2, 3]
+            )
+            items_test = [item_with_name, item_nothing_name, item_empty_name]
+            db_bad_gparent = FUSE.study_database(df_bad_gparent, items_test)
+
+            mktempdir() do save_dir
+                h5file = joinpath(save_dir, "test_bad_gparent.h5")
+                FUSE.save_study_database(h5file, db_bad_gparent; timer=false)
+
+                # Check that values were processed correctly
+                @test db_bad_gparent.df.gparent[1] == "/valid/path"  # normalized
+                @test db_bad_gparent.df.gparent[2] == "/item2"  # auto-generated from nothing name
+                @test db_bad_gparent.df.gparent[3] == "/item3"  # auto-generated from empty name
+            end
+        end
+
+        # Test 3: Large number of items (test padding)
+        @testset "Auto-name padding" begin
+            # Create 15 items to test padding (should use 2 digits)
+            items_many = [FUSE.study_database_item(name=nothing, dd=deepcopy(dd_test)) for _ in 1:15]
+            df_many = DataFrame(case = 1:15)
+            db_many = FUSE.study_database(df_many, items_many)
+
+            mktempdir() do save_dir
+                h5file = joinpath(save_dir, "test_padding.h5")
+                FUSE.save_study_database(h5file, db_many; timer=false)
+
+                # Check padding is correct (should be 2 digits for 15 items)
+                @test db_many.df.gparent[1] == "/item01"
+                @test db_many.df.gparent[9] == "/item09"
+                @test db_many.df.gparent[10] == "/item10"
+                @test db_many.df.gparent[15] == "/item15"
+            end
+        end
+
+        # Test 4: Mixed valid and invalid names
+        @testset "Mixed name scenarios" begin
+            item1 = FUSE.study_database_item(name="group/subgroup", dd=deepcopy(dd_test))
+            item2 = FUSE.study_database_item(name=nothing, dd=deepcopy(dd_test))
+            item3 = FUSE.study_database_item(name="another_group", dd=deepcopy(dd_test))
+
+            df_mixed = DataFrame(
+                gparent = ["/existing", missing, "no_slash"],
+                case = [1, 2, 3]
+            )
+            db_mixed = FUSE.study_database(df_mixed, [item1, item2, item3])
+
+            mktempdir() do save_dir
+                h5file = joinpath(save_dir, "test_mixed.h5")
+                FUSE.save_study_database(h5file, db_mixed; timer=false)
+
+                # First keeps existing valid value
+                @test db_mixed.df.gparent[1] == "/existing"
+                # Second uses auto-generated (since name is nothing)
+                @test db_mixed.df.gparent[2] == "/item2"
+                # Third normalizes the invalid value
+                @test db_mixed.df.gparent[3] == "/no_slash"
+            end
+        end
+
+        # Test 5: Loading and name stripping
+        @testset "Loading with name stripping" begin
+            # Create a db with known names
+            item1 = FUSE.study_database_item(name="test_load", dd=deepcopy(dd_test))
+            df_load = DataFrame(gparent = ["/test_load"], case = [1])
+            db_load = FUSE.study_database(df_load, [item1])
+
+            mktempdir() do save_dir
+                h5file = joinpath(save_dir, "test_load.h5")
+                FUSE.save_study_database(h5file, db_load; timer=false)
+
+                # Load back
+                db_loaded = FUSE.load_study_database(h5file)
+
+                # Name should have leading "/" stripped when loaded
+                @test db_loaded.items[1].name == "test_load"
+                # But :gparent should keep the "/"
+                @test db_loaded.df.gparent[1] == "/test_load"
+            end
+        end
+    end
 end