feat(fixtures): add support for DatasetType in DatasetRecipe and its integration across fixture builders and tests using a new recipe

Author: poikilotherm

src/test/java/edu/harvard/iq/dataverse/util/testing/fixtures/DatasetFixture.java

@@ -5,6 +5,7 @@
 import edu.harvard.iq.dataverse.Dataset;
 import edu.harvard.iq.dataverse.DatasetVersion;
 import edu.harvard.iq.dataverse.FileMetadata;
+import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.datavariable.DataVariable;
 import edu.harvard.iq.dataverse.datavariable.VarGroup;
 import edu.harvard.iq.dataverse.datavariable.VariableMetadata;
@@ -33,6 +34,7 @@
  */
 public record DatasetFixture(
     Dataset dataset,
+    DatasetType datasetType,
     DatasetVersion currentVersion,
     List<FileMetadata> fileMetadatas,
     List<DataFile> dataFiles,

src/test/java/edu/harvard/iq/dataverse/util/testing/fixtures/DatasetFixtureBuilder.java

@@ -5,6 +5,7 @@
 import edu.harvard.iq.dataverse.Dataset;
 import edu.harvard.iq.dataverse.DatasetVersion;
 import edu.harvard.iq.dataverse.FileMetadata;
+import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.datavariable.DataVariable;
 import edu.harvard.iq.dataverse.datavariable.VarGroup;
 import edu.harvard.iq.dataverse.datavariable.VariableMetadata;
@@ -114,6 +115,7 @@ public DatasetFixture build() {
 
         // Create the top-level dataset and its current version, then wire them.
         Dataset dataset = createEmptyDataset(context);
+        DatasetType datasetType = datasetRecipe.datasetTypeRecipe().datasetType();
         DatasetVersion currentVersion = createDatasetVersion(context);
         wireDatasetAndVersion(dataset, currentVersion);
 
@@ -123,7 +125,7 @@ public DatasetFixture build() {
         // Walk the file recipes and create files (plus tabular structure where applicable).
         buildVersionFiles(currentVersion, context, accumulator);
 
-        return accumulator.toFixture(dataset, currentVersion);
+        return accumulator.toFixture(dataset, datasetType, currentVersion);
     }
 
     /**
@@ -138,6 +140,10 @@ public DatasetFixture build() {
     private Dataset createEmptyDataset(BuildContext context) {
         Dataset dataset = new Dataset();
         populator.populateDataset(dataset, context);
+        // DatasetType comes from the recipe, not the populator, because it is a shared
+        // reference entity that must pre-exist in the database. The recipe either wraps
+        //        // a pre-existing instance or builds one from scalar values for this fixture.
+        dataset.setDatasetType(datasetRecipe.datasetTypeRecipe().datasetType());
         dataset.setVersions(new ArrayList<>());
         return dataset;
     }
@@ -481,9 +487,10 @@ void addVariableMetadata(VariableMetadata metadata) {
             variableMetadata.add(metadata);
         }
 
-        DatasetFixture toFixture(Dataset dataset, DatasetVersion currentVersion) {
+        DatasetFixture toFixture(Dataset dataset, DatasetType datasetType, DatasetVersion currentVersion) {
             return new DatasetFixture(
                 dataset,
+                datasetType,
                 currentVersion,
                 fileMetadatas,
                 dataFiles,

src/test/java/edu/harvard/iq/dataverse/util/testing/fixtures/DatasetFixtureTest.java

@@ -6,6 +6,7 @@
 import edu.harvard.iq.dataverse.settings.JvmSettings;
 import edu.harvard.iq.dataverse.util.json.JsonPrinter;
 import edu.harvard.iq.dataverse.util.testing.recipes.DatasetRecipe;
+import edu.harvard.iq.dataverse.util.testing.recipes.DatasetTypeRecipe;
 import edu.harvard.iq.dataverse.util.testing.recipes.FileRecipe;
 import edu.harvard.iq.dataverse.util.testing.recipes.VariableSetRecipe;
 import edu.harvard.iq.dataverse.util.testing.recipes.VersionRecipe;
@@ -38,6 +39,7 @@ static void tearDown() {
     void smoketest() {
 
         var recipe = DatasetRecipe.of(
+            DatasetTypeRecipe.dataset(),
             VersionRecipe.of(
                 FileRecipe.tabular(10, VariableSetRecipe.uniform(10)),
                 //FileRecipe.tabular(50, VariableSetRecipe.byPredicate()),

src/test/java/edu/harvard/iq/dataverse/util/testing/fixtures/MinimalPopulator.java

@@ -6,7 +6,6 @@
 import edu.harvard.iq.dataverse.DatasetVersion;
 import edu.harvard.iq.dataverse.FileMetadata;
 import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
-import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.datavariable.DataVariable;
 import edu.harvard.iq.dataverse.datavariable.VarGroup;
 import edu.harvard.iq.dataverse.datavariable.VariableMetadata;
@@ -31,7 +30,6 @@ public void populateDataset(Dataset dataset, BuildContext context) {
         dataset.setAuthority("10.5072");
         dataset.setIdentifier("fixture-dataset-" + context.sequence());
         dataset.setStorageIdentifier("fixture-storage-" + context.sequence());
-        dataset.setDatasetType(new DatasetType());
 
         // necessary as DvObject says "not nullable"
         dataset.setCreateDate(context.getTimestamp());

src/test/java/edu/harvard/iq/dataverse/util/testing/recipes/DatasetRecipe.java

@@ -1,5 +1,7 @@
 package edu.harvard.iq.dataverse.util.testing.recipes;
 
+import java.util.Objects;
+
 /**
  * Top-level recipe describing how to construct a {@code Dataset} fixture.
  *
@@ -13,31 +15,43 @@
  * to evolve later.</p>
  */
 public interface DatasetRecipe {
-
+    
+    /**
+     * Returns the dataset type recipe providing the type to assign.
+     *
+     * @return dataset type recipe
+     */
+    DatasetTypeRecipe datasetTypeRecipe();
+    
     /**
      * Returns the recipe describing the current version of the dataset.
      *
      * @return recipe for the current dataset version
      */
     VersionRecipe currentVersionRecipe();
-
+    
     /**
-     * Creates a dataset recipe with a single current version recipe.
+     * Creates a dataset recipe with the supplied type and version recipes.
      *
-     * @param currentVersionRecipe the recipe for the current dataset version
+     * @param datasetTypeRecipe recipe providing the dataset type
+     * @param currentVersionRecipe recipe for the current dataset version
      * @return a dataset recipe
      */
-    static DatasetRecipe of(VersionRecipe currentVersionRecipe) {
-        return new SimpleDatasetRecipe(currentVersionRecipe);
+    static DatasetRecipe of(DatasetTypeRecipe datasetTypeRecipe, VersionRecipe currentVersionRecipe) {
+        Objects.requireNonNull(datasetTypeRecipe, "datasetTypeRecipe must not be null");
+        Objects.requireNonNull(currentVersionRecipe, "currentVersionRecipe must not be null");
+        return new SimpleDatasetRecipe(datasetTypeRecipe, currentVersionRecipe);
     }
-
+    
     /**
      * Minimal immutable implementation of {@link DatasetRecipe}.
      *
-     * @param currentVersionRecipe the recipe for the current dataset version
+     * @param datasetTypeRecipe recipe providing the dataset type
+     * @param currentVersionRecipe recipe for the current dataset version
      */
     record SimpleDatasetRecipe(
-            VersionRecipe currentVersionRecipe
+        DatasetTypeRecipe datasetTypeRecipe,
+        VersionRecipe currentVersionRecipe
     ) implements DatasetRecipe {
     }
 }

src/test/java/edu/harvard/iq/dataverse/util/testing/recipes/DatasetTypeRecipe.java

@@ -0,0 +1,93 @@
+package edu.harvard.iq.dataverse.util.testing.recipes;
+
+import edu.harvard.iq.dataverse.dataset.DatasetType;
+
+/**
+ * Recipe providing the {@link DatasetType} to assign to a generated dataset fixture.
+ *
+ * <p>Unlike structural recipes such as {@link VersionRecipe} or {@link FileRecipe},
+ * this is not a construction recipe. It is a reference/creation provider — the
+ * dataset type it produces is expected to be persisted before the dataset fixture
+ * is committed to the database.</p>
+ *
+ * <p>Two factory styles are available:</p>
+ * <ul>
+ *   <li>{@link #of(String, String, String)} — fluent factory that creates a new
+ *       {@link DatasetType} from scalar values. Use this when generating a single
+ *       dataset fixture and you want a self-contained recipe.</li>
+ *   <li>{@link #of(DatasetType)} — wraps a pre-existing instance. Use this when
+ *       you want to share the same type across multiple dataset recipes, or when
+ *       the type has already been persisted elsewhere.</li>
+ * </ul>
+ */
+public interface DatasetTypeRecipe {
+    
+    /**
+     * Returns the dataset type to assign to the generated dataset.
+     *
+     * <p>The returned instance may be newly created or pre-existing, depending on
+     * the implementation. Either way, it must be persisted before the dataset
+     * fixture is committed to the database.</p>
+     *
+     * @return dataset type instance
+     */
+    DatasetType datasetType();
+    
+    /**
+     * Creates a recipe that builds a new {@link DatasetType} from the supplied
+     * scalar values.
+     *
+     * <p>This is the preferred factory for single-dataset fixture scenarios where
+     * the type does not need to be reused or pre-built externally. The resulting
+     * type will need to be persisted before the dataset is committed.</p>
+     *
+     * @param name machine-readable name used in APIs and stored in the database
+     * @param displayName human-readable name shown in the UI
+     * @param description optional description of the dataset type
+     * @return a dataset type recipe producing a new type from the supplied values
+     */
+    static DatasetTypeRecipe of(String name, String displayName, String description) {
+        DatasetType datasetType = new DatasetType();
+        datasetType.setName(name);
+        datasetType.setDisplayName(displayName);
+        datasetType.setDescription(description);
+        return new FixedDatasetTypeRecipe(datasetType);
+    }
+    
+    /**
+     * Creates a recipe that wraps a pre-existing {@link DatasetType} instance.
+     *
+     * <p>Use this when the type has already been persisted, or when you want to
+     * share the same type instance across multiple dataset recipes.</p>
+     *
+     * @param datasetType pre-existing dataset type to use
+     * @return a dataset type recipe wrapping the supplied instance
+     */
+    static DatasetTypeRecipe of(DatasetType datasetType) {
+        return new FixedDatasetTypeRecipe(datasetType);
+    }
+    
+    /**
+     * Creates a recipe using the standard {@value DatasetType#DATASET_TYPE_DATASET}
+     * dataset type with sensible display defaults.
+     *
+     * <p>This is a convenience shortcut for the most common fixture scenario,
+     * where you just need a valid persisted type and do not care about specific
+     * type semantics.</p>
+     *
+     * @return a dataset type recipe for the default dataset type
+     */
+    static DatasetTypeRecipe dataset() {
+        return of(DatasetType.DATASET_TYPE_DATASET, "Dataset", "Standard dataset type for fixtures");
+    }
+    
+    /**
+     * Minimal immutable recipe holding a fixed dataset type instance.
+     *
+     * @param datasetType dataset type to return
+     */
+    record FixedDatasetTypeRecipe(
+        DatasetType datasetType
+    ) implements DatasetTypeRecipe {
+    }
+}