Refactor helper methods in `DataStreamTestHelper` (#130362)

For most of the usages of these methods, it made more sense to return a `ProjectMetadata` instead of a `ClusterState`.
We also don't need to specify a specific project ID; generating a random one inside the helper method saves some boilerplate code.

modules/data-streams/src/test/java/org/elasticsearch/datastreams/DataStreamIndexSettingsProviderTests.java

@@ -11,7 +11,6 @@ package org.elasticsearch.datastreams;
 import org.elasticsearch.cluster.metadata.DataStream;
 import org.elasticsearch.cluster.metadata.DataStreamTestHelper;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
-import org.elasticsearch.cluster.metadata.Metadata;
 import org.elasticsearch.cluster.metadata.ProjectMetadata;
 import org.elasticsearch.common.compress.CompressedXContent;
 import org.elasticsearch.common.settings.Settings;
@@ -53,7 +52,7 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     }
 
     public void testGetAdditionalIndexSettings() throws Exception {
-        ProjectMetadata projectMetadata = Metadata.EMPTY_METADATA.getProject();
+        ProjectMetadata projectMetadata = emptyProject();
         String dataStreamName = "logs-app1";
 
         Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
@@ -96,7 +95,7 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     }
 
     public void testGetAdditionalIndexSettingsIndexRoutingPathAlreadyDefined() throws Exception {
-        ProjectMetadata projectMetadata = Metadata.EMPTY_METADATA.getProject();
+        ProjectMetadata projectMetadata = emptyProject();
         String dataStreamName = "logs-app1";
 
         Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
@@ -140,7 +139,7 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     }
 
     public void testGetAdditionalIndexSettingsMappingsMerging() throws Exception {
-        ProjectMetadata projectMetadata = Metadata.EMPTY_METADATA.getProject();
+        ProjectMetadata projectMetadata = emptyProject();
         String dataStreamName = "logs-app1";
 
         Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
@@ -211,7 +210,7 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     }
 
     public void testGetAdditionalIndexSettingsNoMappings() {
-        ProjectMetadata projectMetadata = Metadata.EMPTY_METADATA.getProject();
+        ProjectMetadata projectMetadata = emptyProject();
         String dataStreamName = "logs-app1";
 
         Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
@@ -235,7 +234,7 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     }
 
     public void testGetAdditionalIndexSettingsLookAheadTime() throws Exception {
-        ProjectMetadata projectMetadata = Metadata.EMPTY_METADATA.getProject();
+        ProjectMetadata projectMetadata = emptyProject();
         String dataStreamName = "logs-app1";
 
         Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
@@ -260,7 +259,7 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     }
 
     public void testGetAdditionalIndexSettingsLookBackTime() throws Exception {
-        ProjectMetadata projectMetadata = Metadata.EMPTY_METADATA.getProject();
+        ProjectMetadata projectMetadata = emptyProject();
         String dataStreamName = "logs-app1";
 
         Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
@@ -290,10 +289,11 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
 
         Instant sixHoursAgo = Instant.now().minus(6, ChronoUnit.HOURS).truncatedTo(ChronoUnit.SECONDS);
         Instant currentEnd = sixHoursAgo.plusMillis(lookAheadTime.getMillis());
-        ProjectMetadata projectMetadata = DataStreamTestHelper.getClusterStateWithDataStream(
+        ProjectMetadata projectMetadata = DataStreamTestHelper.getProjectWithDataStream(
+            randomProjectIdOrDefault(),
             dataStreamName,
             List.of(new Tuple<>(sixHoursAgo, currentEnd))
-        ).getMetadata().getProject();
+        );
 
         Instant now = sixHoursAgo.plus(6, ChronoUnit.HOURS);
         Settings settings = Settings.EMPTY;
@@ -317,18 +317,18 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     public void testGetAdditionalIndexSettingsDataStreamAlreadyCreatedTimeSettingsMissing() {
         String dataStreamName = "logs-app1";
         Instant twoHoursAgo = Instant.now().minus(4, ChronoUnit.HOURS).truncatedTo(ChronoUnit.MILLIS);
-        Metadata.Builder mb = Metadata.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(
+        ProjectMetadata.Builder projectBuilder = ProjectMetadata.builder(
+            DataStreamTestHelper.getProjectWithDataStreams(
                 List.of(Tuple.tuple(dataStreamName, 1)),
                 List.of(),
                 twoHoursAgo.toEpochMilli(),
                 builder().build(),
                 1
-            ).getMetadata()
+            )
         );
-        DataStream ds = mb.dataStream(dataStreamName);
-        mb.put(ds.copy().setIndexMode(IndexMode.TIME_SERIES).build());
-        ProjectMetadata projectMetadata = mb.build().getProject();
+        DataStream ds = projectBuilder.dataStream(dataStreamName);
+        projectBuilder.put(ds.copy().setIndexMode(IndexMode.TIME_SERIES).build());
+        ProjectMetadata projectMetadata = projectBuilder.build();
 
         Instant now = twoHoursAgo.plus(2, ChronoUnit.HOURS);
         Settings settings = Settings.EMPTY;
@@ -356,7 +356,7 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     }
 
     public void testGetAdditionalIndexSettingsNonTsdbTemplate() {
-        ProjectMetadata projectMetadata = Metadata.EMPTY_METADATA.getProject();
+        ProjectMetadata projectMetadata = emptyProject();
         String dataStreamName = "logs-app1";
 
         Settings settings = Settings.EMPTY;
@@ -377,10 +377,9 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
         String dataStreamName = "logs-app1";
         IndexMetadata idx = createFirstBackingIndex(dataStreamName).build();
         DataStream existingDataStream = newInstance(dataStreamName, List.of(idx.getIndex()));
-        ProjectMetadata projectMetadata = Metadata.builder()
+        ProjectMetadata projectMetadata = ProjectMetadata.builder(randomProjectIdOrDefault())
             .dataStreams(Map.of(dataStreamName, existingDataStream), Map.of())
-            .build()
-            .getProject();
+            .build();
 
         Settings settings = Settings.EMPTY;
         Settings result = provider.getAdditionalIndexSettings(
@@ -404,16 +403,13 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     public void testGetAdditionalIndexSettingsDowngradeFromTsdb() {
         String dataStreamName = "logs-app1";
         Instant twoHoursAgo = Instant.now().minus(4, ChronoUnit.HOURS).truncatedTo(ChronoUnit.MILLIS);
-        Metadata.Builder mb = Metadata.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(
-                List.of(Tuple.tuple(dataStreamName, 1)),
-                List.of(),
-                twoHoursAgo.toEpochMilli(),
-                builder().build(),
-                1
-            ).getMetadata()
+        ProjectMetadata projectMetadata = DataStreamTestHelper.getProjectWithDataStreams(
+            List.of(Tuple.tuple(dataStreamName, 1)),
+            List.of(),
+            twoHoursAgo.toEpochMilli(),
+            builder().build(),
+            1
         );
-        ProjectMetadata projectMetadata = mb.build().getProject();
 
         Settings settings = Settings.EMPTY;
         Settings result = provider.getAdditionalIndexSettings(
@@ -691,7 +687,7 @@ public class DataStreamIndexSettingsProviderTests extends ESTestCase {
     }
 
     private Settings generateTsdbSettings(String mapping, Instant now) throws IOException {
-        ProjectMetadata projectMetadata = Metadata.EMPTY_METADATA.getProject();
+        ProjectMetadata projectMetadata = emptyProject();
         String dataStreamName = "logs-app1";
         Settings settings = Settings.EMPTY;
 

modules/data-streams/src/test/java/org/elasticsearch/datastreams/UpdateTimeSeriesRangeServiceTests.java

@@ -14,6 +14,7 @@ import org.apache.logging.log4j.core.LogEvent;
 import org.apache.logging.log4j.core.appender.AbstractAppender;
 import org.apache.logging.log4j.core.filter.RegexFilter;
 import org.apache.logging.log4j.message.Message;
+import org.elasticsearch.cluster.ClusterName;
 import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.metadata.DataStream;
 import org.elasticsearch.cluster.metadata.DataStreamTestHelper;
@@ -196,7 +197,8 @@ public class UpdateTimeSeriesRangeServiceTests extends ESTestCase {
     public void testUpdateTimeSeriesTemporalRange_NoUpdateBecauseRegularDataStream() {
         String dataStreamName = "logs-app1";
         Instant now = Instant.now().truncatedTo(ChronoUnit.MILLIS);
-        ClusterState in = DataStreamTestHelper.getClusterStateWithDataStreams(List.of(new Tuple<>(dataStreamName, 2)), List.of());
+        final var project = DataStreamTestHelper.getProjectWithDataStreams(List.of(new Tuple<>(dataStreamName, 2)), List.of());
+        ClusterState in = ClusterState.builder(ClusterName.DEFAULT).putProjectMetadata(project).build();
 
         now = now.plus(1, ChronoUnit.HOURS);
         ClusterState result = instance.updateTimeSeriesTemporalRange(in, now);

modules/data-streams/src/test/java/org/elasticsearch/datastreams/action/TransportDeleteDataStreamActionTests.java

@@ -10,12 +10,14 @@ package org.elasticsearch.datastreams.action;
 
 import org.elasticsearch.ResourceNotFoundException;
 import org.elasticsearch.action.datastreams.DeleteDataStreamAction;
+import org.elasticsearch.cluster.ClusterName;
 import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.SnapshotsInProgress;
 import org.elasticsearch.cluster.metadata.DataStream;
 import org.elasticsearch.cluster.metadata.DataStreamTestHelper;
 import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
 import org.elasticsearch.cluster.metadata.ProjectId;
+import org.elasticsearch.cluster.metadata.ProjectMetadata;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.collect.ImmutableOpenMap;
 import org.elasticsearch.common.settings.Settings;
@@ -47,24 +49,20 @@ public class TransportDeleteDataStreamActionTests extends ESTestCase {
         final String dataStreamName = "my-data-stream";
         final List<String> otherIndices = randomSubsetOf(List.of("foo", "bar", "baz"));
 
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
-            List.of(new Tuple<>(dataStreamName, 2)),
-            otherIndices
-        );
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(List.of(new Tuple<>(dataStreamName, 2)), otherIndices);
         DeleteDataStreamAction.Request req = new DeleteDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { dataStreamName });
         ClusterState newState = TransportDeleteDataStreamAction.removeDataStream(
             iner,
-            cs.projectState(projectId),
+            projectStateFromProject(project),
             req,
             validator,
             Settings.EMPTY
         );
-        assertThat(newState.metadata().getProject(projectId).dataStreams().size(), equalTo(0));
-        assertThat(newState.metadata().getProject(projectId).indices().size(), equalTo(otherIndices.size()));
+        final var newProject = newState.metadata().getProject(project.id());
+        assertThat(newProject.dataStreams().size(), equalTo(0));
+        assertThat(newProject.indices().size(), equalTo(otherIndices.size()));
         for (String indexName : otherIndices) {
-            assertThat(newState.metadata().getProject(projectId).indices().get(indexName).getIndex().getName(), equalTo(indexName));
+            assertThat(newProject.indices().get(indexName).getIndex().getName(), equalTo(indexName));
         }
     }
 
@@ -72,36 +70,34 @@ public class TransportDeleteDataStreamActionTests extends ESTestCase {
         final String dataStreamName = "my-data-stream";
         final List<String> otherIndices = randomSubsetOf(List.of("foo", "bar", "baz"));
 
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamName, 2)),
             otherIndices,
             System.currentTimeMillis(),
             Settings.EMPTY,
             1,
-            false
+            false,
+            true
         );
         DeleteDataStreamAction.Request req = new DeleteDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { dataStreamName });
         ClusterState newState = TransportDeleteDataStreamAction.removeDataStream(
             iner,
-            cs.projectState(projectId),
+            projectStateFromProject(project),
             req,
             validator,
             Settings.EMPTY
         );
-        assertThat(newState.metadata().getProject(projectId).dataStreams().size(), equalTo(0));
-        assertThat(newState.metadata().getProject(projectId).indices().size(), equalTo(otherIndices.size()));
+        final var newProject = newState.metadata().getProject(project.id());
+        assertThat(newProject.dataStreams().size(), equalTo(0));
+        assertThat(newProject.indices().size(), equalTo(otherIndices.size()));
         for (String indexName : otherIndices) {
-            assertThat(newState.metadata().getProject(projectId).indices().get(indexName).getIndex().getName(), equalTo(indexName));
+            assertThat(newProject.indices().get(indexName).getIndex().getName(), equalTo(indexName));
         }
     }
 
     public void testDeleteMultipleDataStreams() {
         String[] dataStreamNames = { "foo", "bar", "baz", "eggplant" };
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(
                 new Tuple<>(dataStreamNames[0], randomIntBetween(1, 3)),
                 new Tuple<>(dataStreamNames[1], randomIntBetween(1, 3)),
@@ -114,17 +110,18 @@ public class TransportDeleteDataStreamActionTests extends ESTestCase {
         DeleteDataStreamAction.Request req = new DeleteDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { "ba*", "eggplant" });
         ClusterState newState = TransportDeleteDataStreamAction.removeDataStream(
             iner,
-            cs.projectState(projectId),
+            projectStateFromProject(project),
             req,
             validator,
             Settings.EMPTY
         );
-        assertThat(newState.metadata().getProject(projectId).dataStreams().size(), equalTo(1));
-        DataStream remainingDataStream = newState.metadata().getProject(projectId).dataStreams().get(dataStreamNames[0]);
+        final var newProject = newState.metadata().getProject(project.id());
+        assertThat(newProject.dataStreams().size(), equalTo(1));
+        DataStream remainingDataStream = newProject.dataStreams().get(dataStreamNames[0]);
         assertNotNull(remainingDataStream);
-        assertThat(newState.metadata().getProject(projectId).indices().size(), equalTo(remainingDataStream.getIndices().size()));
+        assertThat(newProject.indices().size(), equalTo(remainingDataStream.getIndices().size()));
         for (Index i : remainingDataStream.getIndices()) {
-            assertThat(newState.metadata().getProject(projectId).indices().get(i.getName()).getIndex(), equalTo(i));
+            assertThat(newProject.indices().get(i.getName()).getIndex(), equalTo(i));
         }
     }
 
@@ -133,12 +130,12 @@ public class TransportDeleteDataStreamActionTests extends ESTestCase {
         final String dataStreamName2 = "my-data-stream2";
         final List<String> otherIndices = randomSubsetOf(List.of("foo", "bar", "baz"));
 
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamName, 2), new Tuple<>(dataStreamName2, 2)),
             otherIndices
         );
+        final var projectId = project.id();
+        final ClusterState cs = ClusterState.builder(ClusterName.DEFAULT).putProjectMetadata(project).build();
         SnapshotsInProgress snapshotsInProgress = SnapshotsInProgress.EMPTY.withAddedEntry(
             createEntry(dataStreamName, projectId, "repo1", false)
         ).withAddedEntry(createEntry(dataStreamName2, projectId, "repo2", true));
@@ -180,9 +177,7 @@ public class TransportDeleteDataStreamActionTests extends ESTestCase {
     public void testDeleteNonexistentDataStream() {
         final String dataStreamName = "my-data-stream";
         String[] dataStreamNames = { "foo", "bar", "baz", "eggplant" };
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(
                 new Tuple<>(dataStreamNames[0], randomIntBetween(1, 3)),
                 new Tuple<>(dataStreamNames[1], randomIntBetween(1, 3)),
@@ -191,12 +186,13 @@ public class TransportDeleteDataStreamActionTests extends ESTestCase {
             ),
             List.of()
         );
+        final ClusterState cs = ClusterState.builder(ClusterName.DEFAULT).putProjectMetadata(project).build();
 
         expectThrows(
             ResourceNotFoundException.class,
             () -> TransportDeleteDataStreamAction.removeDataStream(
                 iner,
-                cs.projectState(projectId),
+                cs.projectState(project.id()),
                 new DeleteDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { dataStreamName }),
                 validator,
                 Settings.EMPTY
@@ -209,20 +205,15 @@ public class TransportDeleteDataStreamActionTests extends ESTestCase {
         );
         ClusterState newState = TransportDeleteDataStreamAction.removeDataStream(
             iner,
-            cs.projectState(projectId),
+            cs.projectState(project.id()),
             req,
             validator,
             Settings.EMPTY
         );
         assertThat(newState, sameInstance(cs));
-        assertThat(
-            newState.metadata().getProject(projectId).dataStreams().size(),
-            equalTo(cs.metadata().getProject(projectId).dataStreams().size())
-        );
-        assertThat(
-            newState.metadata().getProject(projectId).dataStreams().keySet(),
-            containsInAnyOrder(cs.metadata().getProject(projectId).dataStreams().keySet().toArray(Strings.EMPTY_ARRAY))
-        );
+        final var newProject = newState.metadata().getProject(project.id());
+        assertThat(newProject.dataStreams().size(), equalTo(project.dataStreams().size()));
+        assertThat(newProject.dataStreams().keySet(), containsInAnyOrder(project.dataStreams().keySet().toArray(Strings.EMPTY_ARRAY)));
     }
 
 }

modules/data-streams/src/test/java/org/elasticsearch/datastreams/action/TransportGetDataStreamsActionTests.java

@@ -20,8 +20,6 @@ import org.elasticsearch.cluster.metadata.DataStreamGlobalRetentionSettings;
 import org.elasticsearch.cluster.metadata.DataStreamTestHelper;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
-import org.elasticsearch.cluster.metadata.Metadata;
-import org.elasticsearch.cluster.metadata.ProjectId;
 import org.elasticsearch.cluster.metadata.ProjectMetadata;
 import org.elasticsearch.cluster.metadata.Template;
 import org.elasticsearch.common.settings.ClusterSettings;
@@ -47,7 +45,6 @@ import java.util.stream.Collectors;
 
 import static org.elasticsearch.cluster.metadata.DataStream.getDefaultBackingIndexName;
 import static org.elasticsearch.cluster.metadata.DataStreamTestHelper.createIndexMetadata;
-import static org.elasticsearch.cluster.metadata.DataStreamTestHelper.getClusterStateWithDataStreams;
 import static org.elasticsearch.test.LambdaMatchers.transformedItemsMatch;
 import static org.elasticsearch.test.LambdaMatchers.transformedMatch;
 import static org.hamcrest.Matchers.allOf;
@@ -72,18 +69,15 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
 
     public void testGetDataStream() {
         final String dataStreamName = "my-data-stream";
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState cs = getClusterStateWithDataStreams(projectId, List.of(new Tuple<>(dataStreamName, 1)), List.of());
+        final var project = DataStreamTestHelper.getProjectWithDataStreams(List.of(new Tuple<>(dataStreamName, 1)), List.of());
         GetDataStreamAction.Request req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { dataStreamName });
-        List<DataStream> dataStreams = TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req);
+        List<DataStream> dataStreams = TransportGetDataStreamsAction.getDataStreams(project, resolver, req);
         assertThat(dataStreams, transformedItemsMatch(DataStream::getName, contains(dataStreamName)));
     }
 
     public void testGetDataStreamsWithWildcards() {
         final String[] dataStreamNames = { "my-data-stream", "another-data-stream" };
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState cs = getClusterStateWithDataStreams(
-            projectId,
+        final var project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamNames[0], 1), new Tuple<>(dataStreamNames[1], 1)),
             List.of()
         );
@@ -92,27 +86,25 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
             TEST_REQUEST_TIMEOUT,
             new String[] { dataStreamNames[1].substring(0, 5) + "*" }
         );
-        List<DataStream> dataStreams = TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req);
+        List<DataStream> dataStreams = TransportGetDataStreamsAction.getDataStreams(project, resolver, req);
         assertThat(dataStreams, transformedItemsMatch(DataStream::getName, contains(dataStreamNames[1])));
 
         req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { "*" });
-        dataStreams = TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req);
+        dataStreams = TransportGetDataStreamsAction.getDataStreams(project, resolver, req);
         assertThat(dataStreams, transformedItemsMatch(DataStream::getName, contains(dataStreamNames[1], dataStreamNames[0])));
 
         req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, (String[]) null);
-        dataStreams = TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req);
+        dataStreams = TransportGetDataStreamsAction.getDataStreams(project, resolver, req);
         assertThat(dataStreams, transformedItemsMatch(DataStream::getName, contains(dataStreamNames[1], dataStreamNames[0])));
 
         req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { "matches-none*" });
-        dataStreams = TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req);
+        dataStreams = TransportGetDataStreamsAction.getDataStreams(project, resolver, req);
         assertThat(dataStreams, empty());
     }
 
     public void testGetDataStreamsWithoutWildcards() {
         final String[] dataStreamNames = { "my-data-stream", "another-data-stream" };
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState cs = getClusterStateWithDataStreams(
-            projectId,
+        final var project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamNames[0], 1), new Tuple<>(dataStreamNames[1], 1)),
             List.of()
         );
@@ -121,33 +113,31 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
             TEST_REQUEST_TIMEOUT,
             new String[] { dataStreamNames[0], dataStreamNames[1] }
         );
-        List<DataStream> dataStreams = TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req);
+        List<DataStream> dataStreams = TransportGetDataStreamsAction.getDataStreams(project, resolver, req);
         assertThat(dataStreams, transformedItemsMatch(DataStream::getName, contains(dataStreamNames[1], dataStreamNames[0])));
 
         req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { dataStreamNames[1] });
-        dataStreams = TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req);
+        dataStreams = TransportGetDataStreamsAction.getDataStreams(project, resolver, req);
         assertThat(dataStreams, transformedItemsMatch(DataStream::getName, contains(dataStreamNames[1])));
 
         req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { dataStreamNames[0] });
-        dataStreams = TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req);
+        dataStreams = TransportGetDataStreamsAction.getDataStreams(project, resolver, req);
         assertThat(dataStreams, transformedItemsMatch(DataStream::getName, contains(dataStreamNames[0])));
 
         GetDataStreamAction.Request req2 = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { "foo" });
         IndexNotFoundException e = expectThrows(
             IndexNotFoundException.class,
-            () -> TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req2)
+            () -> TransportGetDataStreamsAction.getDataStreams(project, resolver, req2)
         );
         assertThat(e.getMessage(), containsString("no such index [foo]"));
     }
 
     public void testGetNonexistentDataStream() {
         final String dataStreamName = "my-data-stream";
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState cs = ClusterState.builder(ClusterName.DEFAULT).putProjectMetadata(ProjectMetadata.builder(projectId).build()).build();
         GetDataStreamAction.Request req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] { dataStreamName });
         IndexNotFoundException e = expectThrows(
             IndexNotFoundException.class,
-            () -> TransportGetDataStreamsAction.getDataStreams(cs.metadata().getProject(projectId), resolver, req)
+            () -> TransportGetDataStreamsAction.getDataStreams(emptyProject(), resolver, req)
         );
         assertThat(e.getMessage(), containsString("no such index [" + dataStreamName + "]"));
     }
@@ -302,22 +292,20 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
         Instant twoHoursAgo = instant.minus(2, ChronoUnit.HOURS);
         Instant twoHoursAhead = instant.plus(2, ChronoUnit.HOURS);
 
-        var projectId = randomProjectIdOrDefault();
-        ClusterState state = getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(Tuple.tuple(dataStream1, 2)),
             List.of(),
             instant.toEpochMilli(),
             Settings.EMPTY,
             0
         );
-        var builder = ProjectMetadata.builder(state.metadata().getProject(projectId));
+        var builder = ProjectMetadata.builder(project);
         DataStreamTestHelper.getClusterStateWithDataStream(builder, dataStream1, List.of(new Tuple<>(twoHoursAgo, twoHoursAhead)));
-        state = ClusterState.builder(state).putProjectMetadata(builder.build()).build();
+        project = builder.build();
 
         var req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] {});
         var response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             req,
             resolver,
             systemIndices,
@@ -347,12 +335,13 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
     }
 
     public void testPassingGlobalRetention() {
-        var projectId = randomProjectIdOrDefault();
-        ClusterState state = getClusterStateWithDataStreams(projectId, List.of(Tuple.tuple("data-stream-1", 2)), List.of());
+        final var state = projectStateFromProject(
+            DataStreamTestHelper.getProjectWithDataStreams(List.of(Tuple.tuple("data-stream-1", 2)), List.of())
+        );
 
         var req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] {});
         var response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            state,
             req,
             resolver,
             systemIndices,
@@ -379,7 +368,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
             )
         );
         response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            state,
             req,
             resolver,
             systemIndices,
@@ -395,9 +384,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
     }
 
     public void testDataStreamIsFailureStoreEffectivelyEnabled_disabled() {
-        var projectId = randomProjectIdOrDefault();
-        ClusterState state = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(Tuple.tuple("data-stream-1", 2)),
             List.of(),
             System.currentTimeMillis(),
@@ -409,7 +396,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
 
         var req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] {});
         var response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             req,
             resolver,
             systemIndices,
@@ -424,10 +411,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
     }
 
     public void testDataStreamIsFailureStoreEffectivelyEnabled_enabledExplicitly() {
-        var projectId = randomProjectIdOrDefault();
-        var metadata = new Metadata.Builder();
-        ClusterState state = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(Tuple.tuple("data-stream-1", 2)),
             List.of(),
             System.currentTimeMillis(),
@@ -439,7 +423,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
 
         var req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] {});
         var response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             req,
             resolver,
             systemIndices,
@@ -454,9 +438,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
     }
 
     public void testDataStreamIsFailureStoreEffectivelyEnabled_enabledByClusterSetting() {
-        var projectId = randomProjectIdOrDefault();
-        ClusterState state = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(Tuple.tuple("data-stream-1", 2)),
             List.of(),
             System.currentTimeMillis(),
@@ -468,7 +450,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
 
         var req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] {});
         var response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             req,
             resolver,
             systemIndices,
@@ -489,24 +471,19 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
     }
 
     public void testProvidersAffectMode() {
-        ClusterState state;
-        var projectId = randomProjectIdOrDefault();
-        {
-            state = DataStreamTestHelper.getClusterStateWithDataStreams(
-                projectId,
-                List.of(Tuple.tuple("data-stream-1", 2)),
-                List.of(),
-                System.currentTimeMillis(),
-                Settings.EMPTY,
-                0,
-                false,
-                false
-            );
-        }
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
+            List.of(Tuple.tuple("data-stream-1", 2)),
+            List.of(),
+            System.currentTimeMillis(),
+            Settings.EMPTY,
+            0,
+            false,
+            false
+        );
 
         var req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] {});
         var response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             req,
             resolver,
             systemIndices,
@@ -543,13 +520,11 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
 
     public void testGetEffectiveSettingsTemplateOnlySettings() {
         // Set a lifecycle only in the template, and make sure that is in the response:
-        ProjectId projectId = randomProjectIdOrDefault();
         GetDataStreamAction.Request req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] {});
         final String templatePolicy = "templatePolicy";
         final String templateIndexMode = IndexMode.LOOKUP.getName();
 
-        ClusterState state = getClusterStateWithDataStreamWithSettings(
-            projectId,
+        ProjectMetadata project = getProjectWithDataStreamWithSettings(
             Settings.builder()
                 .put(IndexMetadata.LIFECYCLE_NAME, templatePolicy)
                 .put(IndexSettings.MODE.getKey(), templateIndexMode)
@@ -559,7 +534,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
         );
 
         GetDataStreamAction.Response response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             req,
             resolver,
             systemIndices,
@@ -577,13 +552,11 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
 
     public void testGetEffectiveSettingsComponentTemplateOnlySettings() {
         // Set a lifecycle only in the template, and make sure that is in the response:
-        ProjectId projectId = randomProjectIdOrDefault();
         GetDataStreamAction.Request req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] {});
         final String templatePolicy = "templatePolicy";
         final String templateIndexMode = IndexMode.LOOKUP.getName();
 
-        ClusterState state = getClusterStateWithDataStreamWithSettings(
-            projectId,
+        ProjectMetadata project = getProjectWithDataStreamWithSettings(
             Settings.EMPTY,
             Settings.builder()
                 .put(IndexMetadata.LIFECYCLE_NAME, templatePolicy)
@@ -593,7 +566,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
         );
 
         GetDataStreamAction.Response response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             req,
             resolver,
             systemIndices,
@@ -610,15 +583,13 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
     }
 
     public void testGetEffectiveSettings() {
-        ProjectId projectId = randomProjectIdOrDefault();
         GetDataStreamAction.Request req = new GetDataStreamAction.Request(TEST_REQUEST_TIMEOUT, new String[] {});
         final String templatePolicy = "templatePolicy";
         final String templateIndexMode = IndexMode.LOOKUP.getName();
         final String dataStreamPolicy = "dataStreamPolicy";
         final String dataStreamIndexMode = IndexMode.LOGSDB.getName();
         // Now set a lifecycle in both the template and the data stream, and make sure the response has the data stream one:
-        ClusterState state = getClusterStateWithDataStreamWithSettings(
-            projectId,
+        ProjectMetadata project = getProjectWithDataStreamWithSettings(
             Settings.builder()
                 .put(IndexMetadata.LIFECYCLE_NAME, templatePolicy)
                 .put(IndexSettings.MODE.getKey(), templateIndexMode)
@@ -633,7 +604,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
                 .build()
         );
         GetDataStreamAction.Response response = TransportGetDataStreamsAction.innerOperation(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             req,
             resolver,
             systemIndices,
@@ -649,8 +620,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
         assertThat(response.getDataStreams().get(0).getIndexModeName(), equalTo(dataStreamIndexMode));
     }
 
-    private static ClusterState getClusterStateWithDataStreamWithSettings(
-        ProjectId projectId,
+    private static ProjectMetadata getProjectWithDataStreamWithSettings(
         Settings templateSettings,
         Settings componentTemplateSettings,
         Settings dataStreamSettings
@@ -660,7 +630,7 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
         long currentTime = System.currentTimeMillis();
         int replicas = 0;
         boolean replicated = false;
-        ProjectMetadata.Builder builder = ProjectMetadata.builder(projectId);
+        ProjectMetadata.Builder builder = ProjectMetadata.builder(randomProjectIdOrDefault());
         builder.put(
             "template_1",
             ComposableIndexTemplate.builder()
@@ -700,6 +670,6 @@ public class TransportGetDataStreamsActionTests extends ESTestCase {
         for (IndexMetadata index : allIndices) {
             builder.put(index, false);
         }
-        return ClusterState.builder(new ClusterName("_name")).putProjectMetadata(builder.build()).build();
+        return builder.build();
     }
 }

server/src/main/java/org/elasticsearch/cluster/metadata/Metadata.java

@@ -1529,11 +1529,6 @@ public class Metadata implements Diffable<Metadata>, ChunkedToXContent {
             return this;
         }
 
-        @Deprecated(forRemoval = true)
-        public DataStream dataStream(String dataStreamName) {
-            return getSingleProject().dataStream(dataStreamName);
-        }
-
         @Deprecated(forRemoval = true)
         public Builder dataStreams(Map<String, DataStream> dataStreams, Map<String, DataStreamAlias> dataStreamAliases) {
             getSingleProject().dataStreams(dataStreams, dataStreamAliases);

server/src/test/java/org/elasticsearch/action/admin/indices/alias/get/TransportGetAliasesActionTests.java

@@ -9,17 +9,14 @@
 package org.elasticsearch.action.admin.indices.alias.get;
 
 import org.apache.logging.log4j.Level;
-import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.metadata.AliasMetadata;
 import org.elasticsearch.cluster.metadata.DataStreamAlias;
 import org.elasticsearch.cluster.metadata.DataStreamTestHelper;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
-import org.elasticsearch.cluster.metadata.Metadata;
 import org.elasticsearch.cluster.metadata.ProjectMetadata;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.util.concurrent.ThreadContext;
-import org.elasticsearch.core.FixForMultiProject;
 import org.elasticsearch.core.Tuple;
 import org.elasticsearch.index.IndexVersion;
 import org.elasticsearch.indices.EmptySystemIndices;
@@ -233,13 +230,11 @@ public class TransportGetAliasesActionTests extends ESTestCase {
     public void testPostProcessDataStreamAliases() {
         var resolver = TestIndexNameExpressionResolver.newInstance();
         var tuples = List.of(new Tuple<>("logs-foo", 1), new Tuple<>("logs-bar", 1), new Tuple<>("logs-baz", 1));
-        @FixForMultiProject(description = "update the helper method to random for non-default project")
-        var clusterState = DataStreamTestHelper.getClusterStateWithDataStreams(tuples, List.of());
-        var builder = Metadata.builder(clusterState.metadata());
+        var builder = ProjectMetadata.builder(DataStreamTestHelper.getProjectWithDataStreams(tuples, List.of()));
         builder.put("logs", "logs-foo", null, null);
         builder.put("logs", "logs-bar", null, null);
         builder.put("secret", "logs-bar", null, null);
-        final ProjectMetadata projectMetadata = ClusterState.builder(clusterState).metadata(builder).build().metadata().getProject();
+        final ProjectMetadata projectMetadata = builder.build();
 
         // return all all data streams with aliases
         var getAliasesRequest = new GetAliasesRequest(TEST_REQUEST_TIMEOUT);

server/src/test/java/org/elasticsearch/action/admin/indices/mapping/put/PutMappingRequestTests.java

@@ -10,12 +10,11 @@
 package org.elasticsearch.action.admin.indices.mapping.put;
 
 import org.elasticsearch.action.ActionRequestValidationException;
-import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.metadata.AliasMetadata;
 import org.elasticsearch.cluster.metadata.DataStreamTestHelper;
 import org.elasticsearch.cluster.metadata.IndexAbstraction;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
-import org.elasticsearch.cluster.metadata.Metadata;
+import org.elasticsearch.cluster.metadata.ProjectMetadata;
 import org.elasticsearch.core.Tuple;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.indices.TestIndexNameExpressionResolver;
@@ -76,22 +75,18 @@ public class PutMappingRequestTests extends ESTestCase {
             tuple(dataStreamNames[2], randomIntBetween(1, 3))
         );
 
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
-        cs = addAliases(
-            cs,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
+        project = addAliases(
+            project,
             List.of(
                 tuple("alias1", List.of(tuple("index1", false), tuple("index2", true))),
                 tuple("alias2", List.of(tuple("index2", false), tuple("index3", true)))
             )
         );
         PutMappingRequest request = new PutMappingRequest().indices("foo", "alias1", "alias2").writeIndexOnly(true);
-        Index[] indices = TransportPutMappingAction.resolveIndices(
-            cs.metadata().getProject(),
-            request,
-            TestIndexNameExpressionResolver.newInstance()
-        );
+        Index[] indices = TransportPutMappingAction.resolveIndices(project, request, TestIndexNameExpressionResolver.newInstance());
         List<String> indexNames = Arrays.stream(indices).map(Index::getName).toList();
-        IndexAbstraction expectedDs = cs.metadata().getProject().getIndicesLookup().get("foo");
+        IndexAbstraction expectedDs = project.getIndicesLookup().get("foo");
         // should resolve the data stream and each alias to their respective write indices
         assertThat(indexNames, containsInAnyOrder(expectedDs.getWriteIndex().getName(), "index2", "index3"));
     }
@@ -104,22 +99,18 @@ public class PutMappingRequestTests extends ESTestCase {
             tuple(dataStreamNames[2], randomIntBetween(1, 3))
         );
 
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
-        cs = addAliases(
-            cs,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
+        project = addAliases(
+            project,
             List.of(
                 tuple("alias1", List.of(tuple("index1", false), tuple("index2", true))),
                 tuple("alias2", List.of(tuple("index2", false), tuple("index3", true)))
             )
         );
         PutMappingRequest request = new PutMappingRequest().indices("foo", "alias1", "alias2");
-        Index[] indices = TransportPutMappingAction.resolveIndices(
-            cs.metadata().getProject(),
-            request,
-            TestIndexNameExpressionResolver.newInstance()
-        );
+        Index[] indices = TransportPutMappingAction.resolveIndices(project, request, TestIndexNameExpressionResolver.newInstance());
         List<String> indexNames = Arrays.stream(indices).map(Index::getName).toList();
-        IndexAbstraction expectedDs = cs.metadata().getProject().getIndicesLookup().get("foo");
+        IndexAbstraction expectedDs = project.getIndicesLookup().get("foo");
         List<String> expectedIndices = expectedDs.getIndices()
             .stream()
             .map(Index::getName)
@@ -137,22 +128,18 @@ public class PutMappingRequestTests extends ESTestCase {
             tuple(dataStreamNames[2], randomIntBetween(1, 3))
         );
 
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
-        cs = addAliases(
-            cs,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
+        project = addAliases(
+            project,
             List.of(
                 tuple("alias1", List.of(tuple("index1", false), tuple("index2", true))),
                 tuple("alias2", List.of(tuple("index2", false), tuple("index3", true)))
             )
         );
         PutMappingRequest request = new PutMappingRequest().indices("foo", "index3").writeIndexOnly(true);
-        Index[] indices = TransportPutMappingAction.resolveIndices(
-            cs.metadata().getProject(),
-            request,
-            TestIndexNameExpressionResolver.newInstance()
-        );
+        Index[] indices = TransportPutMappingAction.resolveIndices(project, request, TestIndexNameExpressionResolver.newInstance());
         List<String> indexNames = Arrays.stream(indices).map(Index::getName).toList();
-        IndexAbstraction expectedDs = cs.metadata().getProject().getIndicesLookup().get("foo");
+        IndexAbstraction expectedDs = project.getIndicesLookup().get("foo");
         List<String> expectedIndices = expectedDs.getIndices()
             .stream()
             .map(Index::getName)
@@ -170,9 +157,9 @@ public class PutMappingRequestTests extends ESTestCase {
             tuple(dataStreamNames[2], randomIntBetween(1, 3))
         );
 
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
-        final ClusterState cs2 = addAliases(
-            cs,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
+        final ProjectMetadata project2 = addAliases(
+            project,
             List.of(
                 tuple("alias1", List.of(tuple("index1", false), tuple("index2", true))),
                 tuple("alias2", List.of(tuple("index2", false), tuple("index3", true)))
@@ -181,11 +168,7 @@ public class PutMappingRequestTests extends ESTestCase {
         PutMappingRequest request = new PutMappingRequest().indices("*").writeIndexOnly(true);
         IllegalArgumentException e = expectThrows(
             IllegalArgumentException.class,
-            () -> TransportPutMappingAction.resolveIndices(
-                cs2.metadata().getProject(),
-                request,
-                TestIndexNameExpressionResolver.newInstance()
-            )
+            () -> TransportPutMappingAction.resolveIndices(project2, request, TestIndexNameExpressionResolver.newInstance())
         );
         assertThat(e.getMessage(), containsString("The index expression [*] and options provided did not point to a single write-index"));
     }
@@ -198,9 +181,9 @@ public class PutMappingRequestTests extends ESTestCase {
             tuple(dataStreamNames[2], randomIntBetween(1, 3))
         );
 
-        ClusterState cs = DataStreamTestHelper.getClusterStateWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
-        final ClusterState cs2 = addAliases(
-            cs,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(dsMetadata, List.of("index1", "index2", "index3"));
+        final ProjectMetadata project2 = addAliases(
+            project,
             List.of(
                 tuple("alias1", List.of(tuple("index1", false), tuple("index2", false))),
                 tuple("alias2", List.of(tuple("index2", false), tuple("index3", false)))
@@ -209,11 +192,7 @@ public class PutMappingRequestTests extends ESTestCase {
         PutMappingRequest request = new PutMappingRequest().indices("alias2").writeIndexOnly(true);
         IllegalArgumentException e = expectThrows(
             IllegalArgumentException.class,
-            () -> TransportPutMappingAction.resolveIndices(
-                cs2.getMetadata().getProject(),
-                request,
-                TestIndexNameExpressionResolver.newInstance()
-            )
+            () -> TransportPutMappingAction.resolveIndices(project2, request, TestIndexNameExpressionResolver.newInstance())
         );
         assertThat(e.getMessage(), containsString("no write index is defined for alias [alias2]"));
     }
@@ -223,8 +202,8 @@ public class PutMappingRequestTests extends ESTestCase {
      * to the alias's indices. The alias's indices are a tuple of index name and a flag indicating whether the alias
      * is a write alias for that index. See usage examples above.
      */
-    private static ClusterState addAliases(ClusterState cs, List<Tuple<String, List<Tuple<String, Boolean>>>> aliases) {
-        Metadata.Builder builder = Metadata.builder(cs.metadata());
+    private static ProjectMetadata addAliases(ProjectMetadata project, List<Tuple<String, List<Tuple<String, Boolean>>>> aliases) {
+        ProjectMetadata.Builder builder = ProjectMetadata.builder(project);
         for (Tuple<String, List<Tuple<String, Boolean>>> alias : aliases) {
             for (Tuple<String, Boolean> index : alias.v2()) {
                 IndexMetadata im = builder.get(index.v1());
@@ -232,7 +211,7 @@ public class PutMappingRequestTests extends ESTestCase {
                 builder.put(IndexMetadata.builder(im).putAlias(newAliasMd));
             }
         }
-        return ClusterState.builder(cs).metadata(builder.build()).build();
+        return builder.build();
     }
 
 }

server/src/test/java/org/elasticsearch/cluster/ClusterStateSerializationTests.java

@@ -12,6 +12,8 @@ package org.elasticsearch.cluster;
 import org.elasticsearch.TransportVersion;
 import org.elasticsearch.TransportVersions;
 import org.elasticsearch.cluster.metadata.DataStreamTestHelper;
+import org.elasticsearch.cluster.metadata.Metadata;
+import org.elasticsearch.cluster.metadata.ProjectMetadata;
 import org.elasticsearch.cluster.node.DiscoveryNode;
 import org.elasticsearch.cluster.node.DiscoveryNodeUtils;
 import org.elasticsearch.cluster.node.DiscoveryNodes;
@@ -77,7 +79,7 @@ public class ClusterStateSerializationTests extends ESTestCase {
             nodes.localNodeId(id);
         } while (randomBoolean());
 
-        ClusterState state = DataStreamTestHelper.getClusterStateWithDataStreams(datastreams, indices);
-        return ClusterState.builder(state).nodes(nodes).build();
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(datastreams, indices);
+        return ClusterState.builder(ClusterName.DEFAULT).metadata(Metadata.builder().put(project)).nodes(nodes).build();
     }
 }

server/src/test/java/org/elasticsearch/cluster/metadata/DataStreamLifecycleWithRetentionWarningsTests.java

@@ -9,7 +9,6 @@
 
 package org.elasticsearch.cluster.metadata;
 
-import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.common.logging.HeaderWarning;
 import org.elasticsearch.common.settings.ClusterSettings;
@@ -129,10 +128,7 @@ public class DataStreamLifecycleWithRetentionWarningsTests extends ESTestCase {
         HeaderWarning.setThreadContext(threadContext);
         String dataStream = randomAlphaOfLength(5);
         TimeValue defaultRetention = randomTimeValue(2, 100, TimeUnit.DAYS);
-        final var projectId = randomProjectIdOrDefault();
-        ProjectMetadata before = ClusterState.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(projectId, List.of(new Tuple<>(dataStream, 2)), List.of())
-        ).build().metadata().getProject(projectId);
+        ProjectMetadata before = DataStreamTestHelper.getProjectWithDataStreams(List.of(new Tuple<>(dataStream, 2)), List.of());
 
         Settings settingsWithDefaultRetention = builder().put(
             DataStreamGlobalRetentionSettings.DATA_STREAMS_DEFAULT_RETENTION_SETTING.getKey(),

server/src/test/java/org/elasticsearch/cluster/metadata/IndexAbstractionResolverTests.java

@@ -52,13 +52,6 @@ public class IndexAbstractionResolverTests extends ESTestCase {
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        final var projectId = randomProjectIdOrDefault();
-        indexNameExpressionResolver = new IndexNameExpressionResolver(
-            new ThreadContext(Settings.EMPTY),
-            EmptySystemIndices.INSTANCE,
-            TestProjectResolvers.singleProject(projectId)
-        );
-        indexAbstractionResolver = new IndexAbstractionResolver(indexNameExpressionResolver);
 
         // Try to resist failing at midnight on the first/last day of the month. Time generally moves forward, so make a timestamp for
         // the next day and if they're different, add both to the cluster state. Check for either in date math tests.
@@ -67,8 +60,7 @@ public class IndexAbstractionResolverTests extends ESTestCase {
         dateTimeIndexToday = IndexNameExpressionResolver.resolveDateMathExpression("<datetime-{now/M}>", timeMillis);
         dateTimeIndexTomorrow = IndexNameExpressionResolver.resolveDateMathExpression("<datetime-{now/M}>", timeTomorrow);
 
-        projectMetadata = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        projectMetadata = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>("data-stream1", 2), new Tuple<>("data-stream2", 2)),
             List.of("index1", "index2", "index3", dateTimeIndexToday, dateTimeIndexTomorrow),
             randomMillisUpToYear9999(),
@@ -76,7 +68,15 @@ public class IndexAbstractionResolverTests extends ESTestCase {
             0,
             false,
             true
-        ).metadata().getProject(projectId);
+        );
+
+        indexNameExpressionResolver = new IndexNameExpressionResolver(
+            new ThreadContext(Settings.EMPTY),
+            EmptySystemIndices.INSTANCE,
+            TestProjectResolvers.singleProject(projectMetadata.id())
+        );
+        indexAbstractionResolver = new IndexAbstractionResolver(indexNameExpressionResolver);
+
     }
 
     public void testResolveIndexAbstractions() {

server/src/test/java/org/elasticsearch/cluster/metadata/IndexNameExpressionResolverTests.java

@@ -3396,12 +3396,12 @@ public class IndexNameExpressionResolverTests extends ESTestCase {
     }
 
     public void testResolveWriteIndexAbstraction() {
-        ClusterState state = DataStreamTestHelper.getClusterStateWithDataStreams(
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>("logs-foobar", 1)),
             List.of("my-index")
         );
-        ProjectMetadata finalState = ProjectMetadata.builder(state.metadata().getProject())
-            .put(IndexMetadata.builder(state.getMetadata().getProject().index("my-index")).putAlias(new AliasMetadata.Builder("my-alias")))
+        ProjectMetadata finalProject = ProjectMetadata.builder(project)
+            .put(IndexMetadata.builder(project.index("my-index")).putAlias(new AliasMetadata.Builder("my-alias")))
             .build();
         Function<String, List<DocWriteRequest<?>>> docWriteRequestsForName = (name) -> List.of(
             new IndexRequest(name).opType(DocWriteRequest.OpType.INDEX),
@@ -3411,40 +3411,38 @@ public class IndexNameExpressionResolverTests extends ESTestCase {
         );
         for (DocWriteRequest<?> request : docWriteRequestsForName.apply("logs-foobar")) {
             if (request.opType() == DocWriteRequest.OpType.CREATE) {
-                IndexAbstraction result = indexNameExpressionResolver.resolveWriteIndexAbstraction(finalState, request);
+                IndexAbstraction result = indexNameExpressionResolver.resolveWriteIndexAbstraction(finalProject, request);
                 assertThat(result.getType(), equalTo(IndexAbstraction.Type.DATA_STREAM));
                 assertThat(result.getName(), equalTo("logs-foobar"));
             } else {
                 IndexNotFoundException infe = expectThrows(
                     IndexNotFoundException.class,
-                    () -> indexNameExpressionResolver.resolveWriteIndexAbstraction(finalState, request)
+                    () -> indexNameExpressionResolver.resolveWriteIndexAbstraction(finalProject, request)
                 );
                 assertThat(infe.toString(), containsString("logs-foobar"));
                 assertThat(infe.getMetadataKeys().contains(IndexNameExpressionResolver.EXCLUDED_DATA_STREAMS_KEY), is(true));
             }
         }
         for (DocWriteRequest<?> request : docWriteRequestsForName.apply("my-index")) {
-            IndexAbstraction result = indexNameExpressionResolver.resolveWriteIndexAbstraction(finalState, request);
+            IndexAbstraction result = indexNameExpressionResolver.resolveWriteIndexAbstraction(finalProject, request);
             assertThat(result.getName(), equalTo("my-index"));
             assertThat(result.getType(), equalTo(IndexAbstraction.Type.CONCRETE_INDEX));
         }
         for (DocWriteRequest<?> request : docWriteRequestsForName.apply("my-alias")) {
-            IndexAbstraction result = indexNameExpressionResolver.resolveWriteIndexAbstraction(finalState, request);
+            IndexAbstraction result = indexNameExpressionResolver.resolveWriteIndexAbstraction(finalProject, request);
             assertThat(result.getName(), equalTo("my-alias"));
             assertThat(result.getType(), equalTo(IndexAbstraction.Type.ALIAS));
         }
     }
 
     public void testResolveWriteIndexAbstractionNoWriteIndexForAlias() {
-        ClusterState state1 = DataStreamTestHelper.getClusterStateWithDataStreams(
+        ProjectMetadata project1 = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>("logs-foobar", 1)),
             List.of("my-index", "my-index2")
         );
-        ProjectMetadata project2 = ProjectMetadata.builder(state1.getMetadata().getProject())
-            .put(IndexMetadata.builder(state1.getMetadata().getProject().index("my-index")).putAlias(new AliasMetadata.Builder("my-alias")))
-            .put(
-                IndexMetadata.builder(state1.getMetadata().getProject().index("my-index2")).putAlias(new AliasMetadata.Builder("my-alias"))
-            )
+        ProjectMetadata project2 = ProjectMetadata.builder(project1)
+            .put(IndexMetadata.builder(project1.index("my-index")).putAlias(new AliasMetadata.Builder("my-alias")))
+            .put(IndexMetadata.builder(project1.index("my-index2")).putAlias(new AliasMetadata.Builder("my-alias")))
             .build();
 
         DocWriteRequest<?> request = new IndexRequest("my-alias");
@@ -3462,18 +3460,16 @@ public class IndexNameExpressionResolverTests extends ESTestCase {
     }
 
     public void testResolveWriteIndexAbstractionMissing() {
-        ProjectMetadata project = DataStreamTestHelper.getClusterStateWithDataStreams(
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>("logs-foobar", 1)),
             List.of("my-index")
-        ).getMetadata().getProject();
+        );
         DocWriteRequest<?> request = new IndexRequest("logs-my-index");
         expectThrows(IndexNotFoundException.class, () -> indexNameExpressionResolver.resolveWriteIndexAbstraction(project, request));
     }
 
     public void testResolveWriteIndexAbstractionMultipleMatches() {
-        ProjectMetadata project = DataStreamTestHelper.getClusterStateWithDataStreams(List.of(), List.of("logs-foo", "logs-bar"))
-            .getMetadata()
-            .getProject();
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(List.of(), List.of("logs-foo", "logs-bar"));
         DocWriteRequest<?> request = mock(DocWriteRequest.class);
         when(request.index()).thenReturn("logs-*");
         when(request.indicesOptions()).thenReturn(IndicesOptions.lenientExpandOpen());

server/src/test/java/org/elasticsearch/cluster/metadata/MetadataDataStreamsServiceTests.java

@@ -426,10 +426,7 @@ public class MetadataDataStreamsServiceTests extends MapperServiceTestCase {
 
     public void testRemoveBrokenBackingIndexReference() {
         var dataStreamName = "my-logs";
-        final var projectId = randomProjectIdOrDefault();
-        var project = DataStreamTestHelper.getClusterStateWithDataStreams(projectId, List.of(new Tuple<>(dataStreamName, 2)), List.of())
-            .metadata()
-            .getProject(projectId);
+        var project = DataStreamTestHelper.getProjectWithDataStreams(List.of(new Tuple<>(dataStreamName, 2)), List.of());
         var originalDs = project.dataStreams().get(dataStreamName);
         var broken = originalDs.copy()
             .setBackingIndices(
@@ -453,11 +450,7 @@ public class MetadataDataStreamsServiceTests extends MapperServiceTestCase {
 
     public void testRemoveBackingIndexThatDoesntExist() {
         var dataStreamName = "my-logs";
-        final var projectId = randomProjectIdOrDefault();
-        var project = DataStreamTestHelper.getClusterStateWithDataStreams(projectId, List.of(new Tuple<>(dataStreamName, 2)), List.of())
-            .metadata()
-            .getProject(projectId);
-        ;
+        var project = DataStreamTestHelper.getProjectWithDataStreams(List.of(new Tuple<>(dataStreamName, 2)), List.of());
 
         String indexToRemove = DataStream.getDefaultBackingIndexName(dataStreamName, 3);
         var e = expectThrows(
@@ -475,12 +468,7 @@ public class MetadataDataStreamsServiceTests extends MapperServiceTestCase {
     public void testUpdateLifecycle() {
         String dataStream = randomAlphaOfLength(5);
         DataStreamLifecycle lifecycle = DataStreamLifecycle.dataLifecycleBuilder().dataRetention(randomPositiveTimeValue()).build();
-        final var projectId = randomProjectIdOrDefault();
-        ProjectMetadata before = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
-            List.of(new Tuple<>(dataStream, 2)),
-            List.of()
-        ).metadata().getProject(projectId);
+        ProjectMetadata before = DataStreamTestHelper.getProjectWithDataStreams(List.of(new Tuple<>(dataStream, 2)), List.of());
         MetadataDataStreamsService service = new MetadataDataStreamsService(
             mock(ClusterService.class),
             mock(IndicesService.class),
@@ -505,18 +493,13 @@ public class MetadataDataStreamsServiceTests extends MapperServiceTestCase {
     }
 
     public void testUpdateDataStreamOptions() {
-        final var projectId = randomProjectIdOrDefault();
         String dataStream = randomAlphaOfLength(5);
         // we want the data stream options to be non-empty, so we can see the removal in action
         DataStreamOptions dataStreamOptions = randomValueOtherThan(
             DataStreamOptions.EMPTY,
             DataStreamOptionsTests::randomDataStreamOptions
         );
-        ProjectMetadata before = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
-            List.of(new Tuple<>(dataStream, 2)),
-            List.of()
-        ).metadata().getProject(projectId);
+        ProjectMetadata before = DataStreamTestHelper.getProjectWithDataStreams(List.of(new Tuple<>(dataStream, 2)), List.of());
         MetadataDataStreamsService service = new MetadataDataStreamsService(
             mock(ClusterService.class),
             mock(IndicesService.class),

server/src/test/java/org/elasticsearch/cluster/metadata/MetadataDeleteIndexServiceTests.java

@@ -192,9 +192,7 @@ public class MetadataDeleteIndexServiceTests extends ESTestCase {
     public void testDeleteBackingIndexForDataStream() {
         int numBackingIndices = randomIntBetween(2, 5);
         String dataStreamName = randomAlphaOfLength(6).toLowerCase(Locale.ROOT);
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState before = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata before = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamName, numBackingIndices)),
             List.of()
         );
@@ -202,24 +200,24 @@ public class MetadataDeleteIndexServiceTests extends ESTestCase {
         // Adjusting the random index to match zero-based indexing of the list
         int numIndexToDelete = randomIntBetween(0, numBackingIndices - 2);
 
-        Index indexToDelete = before.metadata()
-            .getProject(projectId)
-            .index(before.metadata().getProject(projectId).dataStreams().get(dataStreamName).getIndices().get(numIndexToDelete))
-            .getIndex();
-        ClusterState after = MetadataDeleteIndexService.deleteIndices(before, Set.of(indexToDelete), Settings.EMPTY);
+        Index indexToDelete = before.index(before.dataStreams().get(dataStreamName).getIndices().get(numIndexToDelete)).getIndex();
+        ClusterState after = MetadataDeleteIndexService.deleteIndices(
+            projectStateFromProject(before),
+            Set.of(indexToDelete),
+            Settings.EMPTY
+        );
 
-        assertThat(after.metadata().getProject(projectId).indices().get(indexToDelete.getName()), nullValue());
-        assertThat(after.metadata().getProject(projectId).indices().size(), equalTo(numBackingIndices - 1));
-        assertThat(after.metadata().getProject(projectId).indices().get(indexToDelete.getName()), nullValue());
+        final var afterProject = after.metadata().getProject(before.id());
+        assertThat(afterProject.indices().get(indexToDelete.getName()), nullValue());
+        assertThat(afterProject.indices().size(), equalTo(numBackingIndices - 1));
+        assertThat(afterProject.indices().get(indexToDelete.getName()), nullValue());
     }
 
     public void testDeleteFailureIndexForDataStream() {
         long now = System.currentTimeMillis();
         int numBackingIndices = randomIntBetween(2, 5);
         String dataStreamName = randomAlphaOfLength(6).toLowerCase(Locale.ROOT);
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState before = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata before = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamName, numBackingIndices)),
             List.of(),
             now,
@@ -231,30 +229,24 @@ public class MetadataDeleteIndexServiceTests extends ESTestCase {
 
         int numIndexToDelete = randomIntBetween(1, numBackingIndices - 1);
 
-        Index indexToDelete = before.metadata()
-            .getProject(projectId)
-            .index(DataStream.getDefaultFailureStoreName(dataStreamName, numIndexToDelete, now))
-            .getIndex();
-        ClusterState after = MetadataDeleteIndexService.deleteIndices(before, Set.of(indexToDelete), Settings.EMPTY);
-
-        assertThat(after.metadata().getProject(projectId).indices().get(indexToDelete.getName()), nullValue());
-        assertThat(after.metadata().getProject(projectId).indices().size(), equalTo(2 * numBackingIndices - 1));
-        assertThat(
-            after.metadata()
-                .getProject(projectId)
-                .indices()
-                .get(DataStream.getDefaultFailureStoreName(dataStreamName, numIndexToDelete, now)),
-            nullValue()
+        Index indexToDelete = before.index(DataStream.getDefaultFailureStoreName(dataStreamName, numIndexToDelete, now)).getIndex();
+        ClusterState afterState = MetadataDeleteIndexService.deleteIndices(
+            projectStateFromProject(before),
+            Set.of(indexToDelete),
+            Settings.EMPTY
         );
+
+        final var afterProject = afterState.metadata().getProject(before.id());
+        assertThat(afterProject.indices().get(indexToDelete.getName()), nullValue());
+        assertThat(afterProject.indices().size(), equalTo(2 * numBackingIndices - 1));
+        assertThat(afterProject.indices().get(DataStream.getDefaultFailureStoreName(dataStreamName, numIndexToDelete, now)), nullValue());
     }
 
     public void testDeleteMultipleBackingIndexForDataStream() {
         int numBackingIndices = randomIntBetween(3, 5);
         int numBackingIndicesToDelete = randomIntBetween(2, numBackingIndices - 1);
         String dataStreamName = randomAlphaOfLength(6).toLowerCase(Locale.ROOT);
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState before = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata before = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamName, numBackingIndices)),
             List.of()
         );
@@ -266,38 +258,34 @@ public class MetadataDeleteIndexServiceTests extends ESTestCase {
 
         Set<Index> indicesToDelete = new HashSet<>();
         for (int k : indexNumbersToDelete) {
-            final var index = before.metadata().getProject(projectId).dataStreams().get(dataStreamName).getIndices().get(k - 1);
+            final var index = before.dataStreams().get(dataStreamName).getIndices().get(k - 1);
             indicesToDelete.add(index);
         }
-        ClusterState after = MetadataDeleteIndexService.deleteIndices(before, indicesToDelete, Settings.EMPTY);
+        ClusterState after = MetadataDeleteIndexService.deleteIndices(projectStateFromProject(before), indicesToDelete, Settings.EMPTY);
 
-        DataStream dataStream = after.metadata().getProject(projectId).dataStreams().get(dataStreamName);
+        final var afterProject = after.metadata().getProject(before.id());
+        DataStream dataStream = afterProject.dataStreams().get(dataStreamName);
         assertThat(dataStream, notNullValue());
         assertThat(dataStream.getIndices().size(), equalTo(numBackingIndices - indexNumbersToDelete.size()));
         for (Index i : indicesToDelete) {
-            assertThat(after.metadata().getProject(projectId).indices().get(i.getName()), nullValue());
+            assertThat(afterProject.indices().get(i.getName()), nullValue());
             assertFalse(dataStream.getIndices().contains(i));
         }
-        assertThat(after.metadata().getProject(projectId).indices().size(), equalTo(numBackingIndices - indexNumbersToDelete.size()));
+        assertThat(afterProject.indices().size(), equalTo(numBackingIndices - indexNumbersToDelete.size()));
     }
 
     public void testDeleteCurrentWriteIndexForDataStream() {
         int numBackingIndices = randomIntBetween(1, 5);
         String dataStreamName = randomAlphaOfLength(6).toLowerCase(Locale.ROOT);
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState before = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata before = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamName, numBackingIndices)),
             List.of()
         );
 
-        Index indexToDelete = before.metadata()
-            .getProject(projectId)
-            .index(before.metadata().getProject(projectId).dataStreams().get(dataStreamName).getWriteIndex())
-            .getIndex();
+        Index indexToDelete = before.index(before.dataStreams().get(dataStreamName).getWriteIndex()).getIndex();
         Exception e = expectThrows(
             IllegalArgumentException.class,
-            () -> MetadataDeleteIndexService.deleteIndices(before, Set.of(indexToDelete), Settings.EMPTY)
+            () -> MetadataDeleteIndexService.deleteIndices(projectStateFromProject(before), Set.of(indexToDelete), Settings.EMPTY)
         );
 
         assertThat(
@@ -313,9 +301,7 @@ public class MetadataDeleteIndexServiceTests extends ESTestCase {
         int numBackingIndicesToDelete = randomIntBetween(2, numBackingIndices - 1);
         String dataStreamName = randomAlphaOfLength(6).toLowerCase(Locale.ROOT);
         long ts = System.currentTimeMillis();
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState before = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata before = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamName, numBackingIndices)),
             List.of(),
             ts,
@@ -332,29 +318,26 @@ public class MetadataDeleteIndexServiceTests extends ESTestCase {
 
         Set<Index> indicesToDelete = new HashSet<>();
         for (int k : indexNumbersToDelete) {
-            indicesToDelete.add(
-                before.metadata().getProject(projectId).index(DataStream.getDefaultFailureStoreName(dataStreamName, k, ts)).getIndex()
-            );
+            indicesToDelete.add(before.index(DataStream.getDefaultFailureStoreName(dataStreamName, k, ts)).getIndex());
         }
-        ClusterState after = MetadataDeleteIndexService.deleteIndices(before, indicesToDelete, Settings.EMPTY);
+        ClusterState after = MetadataDeleteIndexService.deleteIndices(projectStateFromProject(before), indicesToDelete, Settings.EMPTY);
 
-        DataStream dataStream = after.metadata().getProject(projectId).dataStreams().get(dataStreamName);
+        final var afterProject = after.metadata().getProject(before.id());
+        DataStream dataStream = afterProject.dataStreams().get(dataStreamName);
         assertThat(dataStream, notNullValue());
         assertThat(dataStream.getFailureIndices().size(), equalTo(numBackingIndices - indexNumbersToDelete.size()));
         for (Index i : indicesToDelete) {
-            assertThat(after.metadata().getProject(projectId).indices().get(i.getName()), nullValue());
+            assertThat(afterProject.indices().get(i.getName()), nullValue());
             assertFalse(dataStream.getFailureIndices().contains(i));
         }
-        assertThat(after.metadata().getProject(projectId).indices().size(), equalTo((2 * numBackingIndices) - indexNumbersToDelete.size()));
+        assertThat(afterProject.indices().size(), equalTo((2 * numBackingIndices) - indexNumbersToDelete.size()));
     }
 
     public void testDeleteCurrentWriteFailureIndexForDataStream() {
         int numBackingIndices = randomIntBetween(1, 5);
         String dataStreamName = randomAlphaOfLength(6).toLowerCase(Locale.ROOT);
         long ts = System.currentTimeMillis();
-        final var projectId = randomProjectIdOrDefault();
-        ClusterState before = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata before = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>(dataStreamName, numBackingIndices)),
             List.of(),
             ts,
@@ -364,13 +347,10 @@ public class MetadataDeleteIndexServiceTests extends ESTestCase {
             true
         );
 
-        Index indexToDelete = before.metadata()
-            .getProject(projectId)
-            .index(DataStream.getDefaultFailureStoreName(dataStreamName, numBackingIndices, ts))
-            .getIndex();
+        Index indexToDelete = before.index(DataStream.getDefaultFailureStoreName(dataStreamName, numBackingIndices, ts)).getIndex();
         Exception e = expectThrows(
             IllegalArgumentException.class,
-            () -> MetadataDeleteIndexService.deleteIndices(before, Set.of(indexToDelete), Settings.EMPTY)
+            () -> MetadataDeleteIndexService.deleteIndices(projectStateFromProject(before), Set.of(indexToDelete), Settings.EMPTY)
         );
 
         assertThat(

server/src/test/java/org/elasticsearch/cluster/metadata/MetadataIndexAliasesServiceTests.java

@@ -702,102 +702,100 @@ public class MetadataIndexAliasesServiceTests extends ESTestCase {
     }
 
     public void testDataStreamAliases() {
-        ClusterState state = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>("logs-foobar", 1), new Tuple<>("metrics-foobar", 1)),
             List.of()
         );
 
         ClusterState result = service.applyAliasActions(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             List.of(
                 new AliasAction.AddDataStreamAlias("foobar", "logs-foobar", null, null),
                 new AliasAction.AddDataStreamAlias("foobar", "metrics-foobar", null, null)
             )
         );
-        assertThat(result.metadata().getProject(projectId).dataStreamAliases().get("foobar"), notNullValue());
+        assertThat(result.metadata().getProject(project.id()).dataStreamAliases().get("foobar"), notNullValue());
         assertThat(
-            result.metadata().getProject(projectId).dataStreamAliases().get("foobar").getDataStreams(),
+            result.metadata().getProject(project.id()).dataStreamAliases().get("foobar").getDataStreams(),
             containsInAnyOrder("logs-foobar", "metrics-foobar")
         );
 
         result = service.applyAliasActions(
-            result.projectState(projectId),
+            result.projectState(project.id()),
             List.of(new AliasAction.RemoveDataStreamAlias("foobar", "logs-foobar", null))
         );
-        assertThat(result.metadata().getProject(projectId).dataStreamAliases().get("foobar"), notNullValue());
+        assertThat(result.metadata().getProject(project.id()).dataStreamAliases().get("foobar"), notNullValue());
         assertThat(
-            result.metadata().getProject(projectId).dataStreamAliases().get("foobar").getDataStreams(),
+            result.metadata().getProject(project.id()).dataStreamAliases().get("foobar").getDataStreams(),
             containsInAnyOrder("metrics-foobar")
         );
 
         result = service.applyAliasActions(
-            result.projectState(projectId),
+            result.projectState(project.id()),
             List.of(new AliasAction.RemoveDataStreamAlias("foobar", "metrics-foobar", null))
         );
-        assertThat(result.metadata().getProject(projectId).dataStreamAliases().get("foobar"), nullValue());
+        assertThat(result.metadata().getProject(project.id()).dataStreamAliases().get("foobar"), nullValue());
     }
 
     public void testDataStreamAliasesWithWriteFlag() {
-        ClusterState state = DataStreamTestHelper.getClusterStateWithDataStreams(
-            projectId,
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
             List.of(new Tuple<>("logs-http-emea", 1), new Tuple<>("logs-http-nasa", 1)),
             List.of()
         );
 
         ClusterState result = service.applyAliasActions(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             List.of(
                 new AliasAction.AddDataStreamAlias("logs-http", "logs-http-emea", true, null),
                 new AliasAction.AddDataStreamAlias("logs-http", "logs-http-nasa", null, null)
             )
         );
-        assertThat(result.metadata().getProject(projectId).dataStreamAliases().get("logs-http"), notNullValue());
+        assertThat(result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http"), notNullValue());
         assertThat(
-            result.metadata().getProject(projectId).dataStreamAliases().get("logs-http").getDataStreams(),
+            result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http").getDataStreams(),
             containsInAnyOrder("logs-http-nasa", "logs-http-emea")
         );
         assertThat(
-            result.metadata().getProject(projectId).dataStreamAliases().get("logs-http").getWriteDataStream(),
+            result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http").getWriteDataStream(),
             equalTo("logs-http-emea")
         );
 
         result = service.applyAliasActions(
-            state.projectState(projectId),
+            projectStateFromProject(project),
             List.of(
                 new AliasAction.AddDataStreamAlias("logs-http", "logs-http-emea", false, null),
                 new AliasAction.AddDataStreamAlias("logs-http", "logs-http-nasa", true, null)
             )
         );
-        assertThat(result.metadata().getProject(projectId).dataStreamAliases().get("logs-http"), notNullValue());
+        assertThat(result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http"), notNullValue());
         assertThat(
-            result.metadata().getProject(projectId).dataStreamAliases().get("logs-http").getDataStreams(),
+            result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http").getDataStreams(),
             containsInAnyOrder("logs-http-nasa", "logs-http-emea")
         );
         assertThat(
-            result.metadata().getProject(projectId).dataStreamAliases().get("logs-http").getWriteDataStream(),
+            result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http").getWriteDataStream(),
             equalTo("logs-http-nasa")
         );
 
         result = service.applyAliasActions(
-            result.projectState(projectId),
+            result.projectState(project.id()),
             List.of(new AliasAction.RemoveDataStreamAlias("logs-http", "logs-http-emea", null))
         );
-        assertThat(result.metadata().getProject(projectId).dataStreamAliases().get("logs-http"), notNullValue());
+        assertThat(result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http"), notNullValue());
         assertThat(
-            result.metadata().getProject(projectId).dataStreamAliases().get("logs-http").getDataStreams(),
+            result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http").getDataStreams(),
             contains("logs-http-nasa")
         );
         assertThat(
-            result.metadata().getProject(projectId).dataStreamAliases().get("logs-http").getWriteDataStream(),
+            result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http").getWriteDataStream(),
             equalTo("logs-http-nasa")
         );
 
         result = service.applyAliasActions(
-            result.projectState(projectId),
+            result.projectState(project.id()),
             List.of(new AliasAction.RemoveDataStreamAlias("logs-http", "logs-http-nasa", null))
         );
-        assertThat(result.metadata().getProject(projectId).dataStreamAliases().get("logs-http"), nullValue());
+        assertThat(result.metadata().getProject(project.id()).dataStreamAliases().get("logs-http"), nullValue());
     }
 
     public void testAddAndRemoveAliasClusterStateUpdate() throws Exception {

test/framework/src/main/java/org/elasticsearch/cluster/metadata/DataStreamTestHelper.java

@@ -87,6 +87,7 @@ import static org.elasticsearch.test.ESTestCase.randomIntBetween;
 import static org.elasticsearch.test.ESTestCase.randomMap;
 import static org.elasticsearch.test.ESTestCase.randomMillisUpToYear9999;
 import static org.elasticsearch.test.ESTestCase.randomPositiveTimeValue;
+import static org.elasticsearch.test.ESTestCase.randomProjectIdOrDefault;
 import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
@@ -441,63 +442,36 @@ public final class DataStreamTestHelper {
      * @param dataStreams The names of the data streams to create with their respective number of backing indices
      * @param indexNames  The names of indices to create that do not back any data streams
      */
-    @FixForMultiProject(description = "Don't use default project id")
-    @Deprecated(forRemoval = true)
-    public static ClusterState getClusterStateWithDataStreams(List<Tuple<String, Integer>> dataStreams, List<String> indexNames) {
-        return getClusterStateWithDataStreams(Metadata.DEFAULT_PROJECT_ID, dataStreams, indexNames);
+    public static ProjectMetadata getProjectWithDataStreams(List<Tuple<String, Integer>> dataStreams, List<String> indexNames) {
+        return getProjectWithDataStreams(dataStreams, indexNames, System.currentTimeMillis(), Settings.EMPTY, 1);
     }
 
-    /**
-     * Constructs {@code ClusterState} with the specified data streams and indices.
-     *
-     * @param projectId The id of the project to which the data streams should be added to
-     * @param dataStreams The names of the data streams to create with their respective number of backing indices
-     * @param indexNames The names of indices to create that do not back any data streams
-     */
-    public static ClusterState getClusterStateWithDataStreams(
-        ProjectId projectId,
-        List<Tuple<String, Integer>> dataStreams,
-        List<String> indexNames
-    ) {
-        return getClusterStateWithDataStreams(projectId, dataStreams, indexNames, System.currentTimeMillis(), Settings.EMPTY, 1);
-    }
-
-    @FixForMultiProject(description = "Don't use default project id")
-    @Deprecated(forRemoval = true)
-    public static ClusterState getClusterStateWithDataStreams(
+    public static ProjectMetadata getProjectWithDataStreams(
         List<Tuple<String, Integer>> dataStreams,
         List<String> indexNames,
         long currentTime,
         Settings settings,
         int replicas
     ) {
-        return getClusterStateWithDataStreams(Metadata.DEFAULT_PROJECT_ID, dataStreams, indexNames, currentTime, settings, replicas);
+        return getProjectWithDataStreams(dataStreams, indexNames, currentTime, settings, replicas, false, false);
     }
 
-    public static ClusterState getClusterStateWithDataStreams(
-        ProjectId projectId,
-        List<Tuple<String, Integer>> dataStreams,
-        List<String> indexNames,
-        long currentTime,
-        Settings settings,
-        int replicas
-    ) {
-        return getClusterStateWithDataStreams(projectId, dataStreams, indexNames, currentTime, settings, replicas, false);
-    }
-
-    public static ClusterState getClusterStateWithDataStreams(
-        ProjectId projectId,
+    public static ProjectMetadata getProjectWithDataStreams(
         List<Tuple<String, Integer>> dataStreams,
         List<String> indexNames,
         long currentTime,
         Settings settings,
         int replicas,
-        boolean replicated
+        boolean replicated,
+        Boolean storeFailures
     ) {
-        return getClusterStateWithDataStreams(projectId, dataStreams, indexNames, currentTime, settings, replicas, replicated, false);
+        final var projectId = randomProjectIdOrDefault();
+        return getProjectWithDataStreams(projectId, dataStreams, indexNames, currentTime, settings, replicas, replicated, storeFailures);
     }
 
-    public static ClusterState getClusterStateWithDataStreams(
+    @FixForMultiProject() // Remove this method overload when ProactiveStorageDeciderServiceTests no longer needs the default project ID
+    @Deprecated(forRemoval = true)
+    public static ProjectMetadata getProjectWithDataStreams(
         ProjectId projectId,
         List<Tuple<String, Integer>> dataStreams,
         List<String> indexNames,
@@ -561,7 +535,7 @@ public final class DataStreamTestHelper {
         for (IndexMetadata index : allIndices) {
             builder.put(index, false);
         }
-        return ClusterState.builder(new ClusterName("_name")).putProjectMetadata(builder.build()).build();
+        return builder.build();
     }
 
     @FixForMultiProject(description = "Don't use default project id")

test/framework/src/main/java/org/elasticsearch/test/ESTestCase.java

@@ -2897,10 +2897,24 @@ public abstract class ESTestCase extends LuceneTestCase {
         return ClusterState.builder(ClusterName.DEFAULT).putProjectMetadata(project).build().projectState(project.getId());
     }
 
+    /**
+     * Constructs a {@link ProjectState} for the given {@link ProjectMetadata}.
+     */
+    public static ProjectState projectStateFromProject(ProjectMetadata project) {
+        return ClusterState.builder(ClusterName.DEFAULT).putProjectMetadata(project).build().projectState(project.id());
+    }
+
     /**
      * Constructs an empty {@link ProjectState} with one (empty) project.
      */
     public static ProjectState projectStateWithEmptyProject() {
         return projectStateFromProject(ProjectMetadata.builder(randomProjectIdOrDefault()));
     }
+
+    /**
+     * Constructs an empty {@link ProjectMetadata} with a random ID.
+     */
+    public static ProjectMetadata emptyProject() {
+        return ProjectMetadata.builder(randomProjectIdOrDefault()).build();
+    }
 }

x-pack/plugin/autoscaling/src/test/java/org/elasticsearch/xpack/autoscaling/storage/ProactiveStorageDeciderServiceTests.java

@@ -9,13 +9,16 @@ package org.elasticsearch.xpack.autoscaling.storage;
 
 import org.elasticsearch.cluster.ClusterInfo;
 import org.elasticsearch.cluster.ClusterModule;
+import org.elasticsearch.cluster.ClusterName;
 import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.DiskUsage;
+import org.elasticsearch.cluster.ProjectState;
 import org.elasticsearch.cluster.TestShardRoutingRoleStrategies;
 import org.elasticsearch.cluster.metadata.DataStream;
 import org.elasticsearch.cluster.metadata.DataStreamTestHelper;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.metadata.Metadata;
+import org.elasticsearch.cluster.metadata.ProjectMetadata;
 import org.elasticsearch.cluster.node.DiscoveryNode;
 import org.elasticsearch.cluster.node.DiscoveryNodeRole;
 import org.elasticsearch.cluster.routing.RoutingNode;
@@ -30,6 +33,7 @@ import org.elasticsearch.cluster.routing.allocation.decider.DiskThresholdDecider
 import org.elasticsearch.common.settings.ClusterSettings;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.util.set.Sets;
+import org.elasticsearch.core.FixForMultiProject;
 import org.elasticsearch.core.TimeValue;
 import org.elasticsearch.core.Tuple;
 import org.elasticsearch.index.Index;
@@ -60,28 +64,25 @@ import static org.hamcrest.Matchers.startsWith;
 
 public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
     public void testScale() {
-        ClusterState originalState = DataStreamTestHelper.getClusterStateWithDataStreams(
+        @FixForMultiProject(description = "Use non-default project ID and remove last boolean parameter")
+        ProjectMetadata originalProject = DataStreamTestHelper.getProjectWithDataStreams(
             Metadata.DEFAULT_PROJECT_ID,
             List.of(Tuple.tuple("test", between(1, 10))),
             List.of(),
             System.currentTimeMillis(),
             Settings.EMPTY,
             0,
-            randomBoolean()
+            randomBoolean(),
+            false
         );
-        ClusterState.Builder stateBuilder = ClusterState.builder(originalState);
+        ClusterState.Builder stateBuilder = ClusterState.builder(ClusterName.DEFAULT);
         IntStream.range(0, between(1, 10)).forEach(i -> ReactiveStorageDeciderServiceTests.addNode(stateBuilder));
-        stateBuilder.routingTable(
-            addRouting(originalState.metadata().getProject(), RoutingTable.builder(TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY))
-                .build()
+        stateBuilder.putRoutingTable(
+            originalProject.id(),
+            addRouting(originalProject, RoutingTable.builder(TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY)).build()
         );
-        long lastCreated = System.currentTimeMillis();
-        applyCreatedDates(
-            originalState,
-            stateBuilder,
-            (DataStream) originalState.metadata().getProject().getIndicesLookup().get("test"),
-            lastCreated,
-            1
+        stateBuilder.putProjectMetadata(
+            applyCreatedDates(originalProject, (DataStream) originalProject.getIndicesLookup().get("test"), System.currentTimeMillis(), 1)
         );
         ClusterState interimState = stateBuilder.build();
         final ClusterState state = startAll(interimState);
@@ -103,7 +104,7 @@ public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
             TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY
         );
         AutoscalingCapacity currentCapacity = ReactiveStorageDeciderDecisionTests.randomCurrentCapacity();
-        ClusterInfo info = randomClusterInfo(state);
+        ClusterInfo info = randomClusterInfo(state.projectState(originalProject.id()));
         AutoscalingDeciderContext context = new AutoscalingDeciderContext() {
             @Override
             public ClusterState state() {
@@ -151,7 +152,11 @@ public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
             assertThat(
                 reason.forecasted(),
                 lessThanOrEqualTo(
-                    totalSize(state.metadata().getProject().dataStreams().get("test").getIndices(), state.routingTable(), info)
+                    totalSize(
+                        state.metadata().getProject(originalProject.id()).dataStreams().get("test").getIndices(),
+                        state.routingTable(originalProject.id()),
+                        info
+                    )
                 )
             );
 
@@ -170,21 +175,24 @@ public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
     }
 
     public void testForecastNoDates() {
-        ClusterState originalState = DataStreamTestHelper.getClusterStateWithDataStreams(
+        @FixForMultiProject(description = "Use non-default project ID and remove last boolean parameter")
+        ProjectMetadata originalProject = DataStreamTestHelper.getProjectWithDataStreams(
             Metadata.DEFAULT_PROJECT_ID,
             List.of(Tuple.tuple("test", between(1, 10))),
             List.of(),
             System.currentTimeMillis(),
             Settings.EMPTY,
             between(0, 4),
-            randomBoolean()
+            randomBoolean(),
+            false
         );
-        ClusterState.Builder stateBuilder = ClusterState.builder(originalState);
-        stateBuilder.routingTable(
-            addRouting(originalState.metadata().getProject(), RoutingTable.builder(TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY))
-                .build()
-        );
-        ClusterState state = stateBuilder.build();
+        ClusterState state = ClusterState.builder(ClusterName.DEFAULT)
+            .putProjectMetadata(originalProject)
+            .putRoutingTable(
+                originalProject.id(),
+                addRouting(originalProject, RoutingTable.builder(TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY)).build()
+            )
+            .build();
         ReactiveStorageDeciderService.AllocationState allocationState = new ReactiveStorageDeciderService.AllocationState(
             state,
             null,
@@ -200,26 +208,26 @@ public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
     }
 
     public void testForecastZero() {
-        ClusterState originalState = DataStreamTestHelper.getClusterStateWithDataStreams(
+        @FixForMultiProject(description = "Use non-default project ID and remove last two boolean parameters")
+        ProjectMetadata originalProject = DataStreamTestHelper.getProjectWithDataStreams(
+            Metadata.DEFAULT_PROJECT_ID,
             List.of(Tuple.tuple("test", between(1, 10))),
             List.of(),
             System.currentTimeMillis(),
             Settings.EMPTY,
-            between(0, 4)
+            between(0, 4),
+            false,
+            false
         );
-        ClusterState.Builder stateBuilder = ClusterState.builder(originalState);
+        ClusterState.Builder stateBuilder = ClusterState.builder(ClusterName.DEFAULT);
         IntStream.range(0, between(1, 10)).forEach(i -> ReactiveStorageDeciderServiceTests.addNode(stateBuilder));
-        stateBuilder.routingTable(
-            addRouting(originalState.metadata().getProject(), RoutingTable.builder(TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY))
-                .build()
+        stateBuilder.putRoutingTable(
+            originalProject.id(),
+            addRouting(originalProject, RoutingTable.builder(TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY)).build()
         );
         long lastCreated = randomNonNegativeLong();
-        applyCreatedDates(
-            originalState,
-            stateBuilder,
-            (DataStream) originalState.metadata().getProject().getIndicesLookup().get("test"),
-            lastCreated,
-            1
+        stateBuilder.putProjectMetadata(
+            applyCreatedDates(originalProject, (DataStream) originalProject.getIndicesLookup().get("test"), lastCreated, 1)
         );
         ClusterState state = stateBuilder.build();
         state = randomAllocate(state);
@@ -228,7 +236,7 @@ public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
             null,
             TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY,
             null,
-            randomClusterInfo(state),
+            randomClusterInfo(state.projectState(originalProject.id())),
             null,
             Sets.newHashSet(state.nodes()),
             Set.of()
@@ -241,36 +249,35 @@ public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
     public void testForecast() {
         int indices = between(1, 10);
         int shardCopies = between(1, 2);
-        ClusterState originalState = DataStreamTestHelper.getClusterStateWithDataStreams(
-            Metadata.DEFAULT_PROJECT_ID,
+        @FixForMultiProject(description = "Use non-default project ID and remove last boolean parameter")
+        final var projectId = Metadata.DEFAULT_PROJECT_ID;
+        ProjectMetadata originalProject = DataStreamTestHelper.getProjectWithDataStreams(
+            projectId,
             List.of(Tuple.tuple("test", indices)),
             List.of(),
             System.currentTimeMillis(),
             Settings.EMPTY,
             shardCopies - 1,
-            randomBoolean()
+            randomBoolean(),
+            false
         );
-        ClusterState.Builder stateBuilder = ClusterState.builder(originalState);
-        stateBuilder.routingTable(
-            addRouting(originalState.metadata().getProject(), RoutingTable.builder(TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY))
-                .build()
+        ClusterState.Builder stateBuilder = ClusterState.builder(ClusterName.DEFAULT);
+        stateBuilder.putRoutingTable(
+            projectId,
+            addRouting(originalProject, RoutingTable.builder(TestShardRoutingRoleStrategies.DEFAULT_ROLE_ONLY)).build()
         );
         IntStream.range(0, between(1, 10)).forEach(i -> ReactiveStorageDeciderServiceTests.addNode(stateBuilder));
         long lastCreated = randomNonNegativeLong();
-        applyCreatedDates(
-            originalState,
-            stateBuilder,
-            (DataStream) originalState.metadata().getProject().getIndicesLookup().get("test"),
-            lastCreated,
-            1
+        stateBuilder.putProjectMetadata(
+            applyCreatedDates(originalProject, (DataStream) originalProject.getIndicesLookup().get("test"), lastCreated, 1)
         );
         ClusterState state = stateBuilder.build();
 
         state = randomAllocate(state);
 
-        DataStream dataStream = state.metadata().getProject().dataStreams().get("test");
+        DataStream dataStream = state.metadata().getProject(projectId).dataStreams().get("test");
 
-        ClusterInfo info = randomClusterInfo(state);
+        ClusterInfo info = randomClusterInfo(state.projectState(projectId));
 
         ReactiveStorageDeciderService.AllocationState allocationState = new ReactiveStorageDeciderService.AllocationState(
             state,
@@ -287,12 +294,12 @@ public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
             ReactiveStorageDeciderService.AllocationState forecast = allocationState.forecast(window, lastCreated + 1);
             int actualWindow = Math.min(window, indices);
             int expectedIndices = actualWindow + indices;
-            assertThat(forecast.state().metadata().getProject().indices().size(), Matchers.equalTo(expectedIndices));
-            DataStream forecastDataStream = forecast.state().metadata().getProject().dataStreams().get("test");
+            assertThat(forecast.state().metadata().getProject(projectId).indices().size(), Matchers.equalTo(expectedIndices));
+            DataStream forecastDataStream = forecast.state().metadata().getProject(projectId).dataStreams().get("test");
             assertThat(forecastDataStream.getIndices().size(), Matchers.equalTo(expectedIndices));
             assertThat(forecastDataStream.getIndices().subList(0, indices), Matchers.equalTo(dataStream.getIndices()));
 
-            RoutingTable forecastRoutingTable = forecast.state().routingTable();
+            RoutingTable forecastRoutingTable = forecast.state().routingTable(projectId);
             assertThat(forecastRoutingTable.allShards().count(), Matchers.equalTo((long) (expectedIndices) * shardCopies));
 
             forecastDataStream.getIndices()
@@ -300,7 +307,11 @@ public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
 
             forecastRoutingTable.allShards().forEach(s -> assertThat(forecast.info().getShardSize(s), Matchers.notNullValue()));
 
-            long expectedTotal = totalSize(dataStream.getIndices().subList(indices - actualWindow, indices), state.routingTable(), info);
+            long expectedTotal = totalSize(
+                dataStream.getIndices().subList(indices - actualWindow, indices),
+                state.routingTable(projectId),
+                info
+            );
             List<Index> addedIndices = forecastDataStream.getIndices().subList(indices, forecastDataStream.getIndices().size());
             long actualTotal = totalSize(addedIndices, forecastRoutingTable, forecast.info());
 
@@ -388,32 +399,26 @@ public class ProactiveStorageDeciderServiceTests extends AutoscalingTestCase {
         return builder;
     }
 
-    private ClusterInfo randomClusterInfo(ClusterState state) {
-        Map<String, Long> shardSizes = state.routingTable()
+    private ClusterInfo randomClusterInfo(ProjectState projectState) {
+        Map<String, Long> shardSizes = projectState.routingTable()
             .allShards()
             .map(ClusterInfo::shardIdentifierFromRouting)
             .collect(Collectors.toMap(Function.identity(), id -> randomLongBetween(1, 1000), (v1, v2) -> v1));
         Map<String, DiskUsage> diskUsage = new HashMap<>();
-        for (var id : state.nodes().getDataNodes().keySet()) {
+        for (var id : projectState.cluster().nodes().getDataNodes().keySet()) {
             diskUsage.put(id, new DiskUsage(id, id, "/test", Long.MAX_VALUE, Long.MAX_VALUE));
         }
         return new ClusterInfo(diskUsage, diskUsage, shardSizes, Map.of(), Map.of(), Map.of(), Map.of());
     }
 
-    private ClusterState.Builder applyCreatedDates(
-        ClusterState state,
-        ClusterState.Builder builder,
-        DataStream ds,
-        long last,
-        long decrement
-    ) {
-        Metadata.Builder metadataBuilder = Metadata.builder(state.metadata());
+    private ProjectMetadata applyCreatedDates(ProjectMetadata project, DataStream ds, long last, long decrement) {
+        ProjectMetadata.Builder projectBuilder = ProjectMetadata.builder(project);
         List<Index> indices = ds.getIndices();
         long start = last - (decrement * (indices.size() - 1));
         for (int i = 0; i < indices.size(); ++i) {
-            IndexMetadata previousInstance = state.metadata().getProject().index(indices.get(i));
-            metadataBuilder.put(IndexMetadata.builder(previousInstance).creationDate(start + (i * decrement)).build(), false);
+            IndexMetadata previousInstance = project.index(indices.get(i));
+            projectBuilder.put(IndexMetadata.builder(previousInstance).creationDate(start + (i * decrement)).build(), false);
         }
-        return builder.metadata(metadataBuilder);
+        return projectBuilder.build();
     }
 }

x-pack/plugin/logsdb/src/test/java/org/elasticsearch/xpack/logsdb/LogsdbIndexModeSettingsProviderTests.java

@@ -120,7 +120,6 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
     }
 
     private Settings generateLogsdbSettings(Settings settings, String mapping, Version version) throws IOException {
-        Metadata metadata = Metadata.EMPTY_METADATA;
         var provider = new LogsdbIndexModeSettingsProvider(
             logsdbLicenseService,
             Settings.builder().put("cluster.logsdb.enabled", true).build()
@@ -133,7 +132,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             DataStream.getDefaultBackingIndexName(DATA_STREAM_NAME, 0),
             DATA_STREAM_NAME,
             IndexMode.LOGSDB,
-            metadata.getProject(),
+            emptyProject(),
             Instant.now(),
             settings,
             mapping == null ? List.of() : List.of(new CompressedXContent(mapping))
@@ -151,7 +150,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             null,
             "logs-apache-production",
             null,
-            Metadata.EMPTY_METADATA.getProject(),
+            emptyProject(),
             Instant.now().truncatedTo(ChronoUnit.SECONDS),
             Settings.EMPTY,
             List.of(new CompressedXContent(DEFAULT_MAPPING))
@@ -170,7 +169,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             "logs-apache-production",
             null,
             null,
-            Metadata.EMPTY_METADATA.getProject(),
+            emptyProject(),
             Instant.now().truncatedTo(ChronoUnit.SECONDS),
             Settings.EMPTY,
             List.of(new CompressedXContent(DEFAULT_MAPPING))
@@ -189,7 +188,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             null,
             "logs-apache-production",
             null,
-            Metadata.EMPTY_METADATA.getProject(),
+            emptyProject(),
             Instant.now().truncatedTo(ChronoUnit.SECONDS),
             Settings.builder().put(IndexSettings.MODE.getKey(), IndexMode.STANDARD.getName()).build(),
             List.of(new CompressedXContent(DEFAULT_MAPPING))
@@ -208,7 +207,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             null,
             "logs-apache-production",
             null,
-            Metadata.EMPTY_METADATA.getProject(),
+            emptyProject(),
             Instant.now().truncatedTo(ChronoUnit.SECONDS),
             Settings.builder().put(IndexSettings.MODE.getKey(), IndexMode.TIME_SERIES.getName()).build(),
             List.of(new CompressedXContent(DEFAULT_MAPPING))
@@ -227,7 +226,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             null,
             "logs",
             null,
-            Metadata.EMPTY_METADATA.getProject(),
+            emptyProject(),
             Instant.now().truncatedTo(ChronoUnit.SECONDS),
             Settings.EMPTY,
             List.of(new CompressedXContent(DEFAULT_MAPPING))
@@ -321,7 +320,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             null,
             "LOGS-apache-production",
             null,
-            Metadata.EMPTY_METADATA.getProject(),
+            emptyProject(),
             Instant.now().truncatedTo(ChronoUnit.SECONDS),
             Settings.EMPTY,
             List.of(new CompressedXContent(DEFAULT_MAPPING))
@@ -337,7 +336,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             null,
             "logs-apache-production-eu",
             null,
-            Metadata.EMPTY_METADATA.getProject(),
+            emptyProject(),
             Instant.now().truncatedTo(ChronoUnit.SECONDS),
             Settings.EMPTY,
             List.of(new CompressedXContent(DEFAULT_MAPPING))
@@ -623,16 +622,13 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
 
     public void testGetAdditionalIndexSettingsDowngradeFromSyntheticSource() {
         String dataStreamName = DATA_STREAM_NAME;
-        Metadata.Builder mb = Metadata.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(
-                List.of(Tuple.tuple(dataStreamName, 1)),
-                List.of(),
-                Instant.now().toEpochMilli(),
-                builder().build(),
-                1
-            ).getMetadata()
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
+            List.of(Tuple.tuple(dataStreamName, 1)),
+            List.of(),
+            Instant.now().toEpochMilli(),
+            builder().build(),
+            1
         );
-        Metadata metadata = mb.build();
         LogsdbIndexModeSettingsProvider provider = withSyntheticSourceDemotionSupport(false);
         Settings settings = builder().put(IndexSettings.INDEX_MAPPER_SOURCE_MODE_SETTING.getKey(), SourceFieldMapper.Mode.SYNTHETIC)
             .build();
@@ -641,7 +637,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             DataStream.getDefaultBackingIndexName(dataStreamName, 2),
             dataStreamName,
             null,
-            metadata.getProject(),
+            project,
             Instant.ofEpochMilli(1L),
             settings,
             List.of()
@@ -654,7 +650,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             DataStream.getDefaultBackingIndexName(dataStreamName, 2),
             dataStreamName,
             null,
-            metadata.getProject(),
+            project,
             Instant.ofEpochMilli(1L),
             settings,
             List.of()
@@ -667,7 +663,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             DataStream.getDefaultBackingIndexName(dataStreamName, 2),
             dataStreamName,
             IndexMode.TIME_SERIES,
-            metadata.getProject(),
+            project,
             Instant.ofEpochMilli(1L),
             settings,
             List.of()
@@ -680,7 +676,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             DataStream.getDefaultBackingIndexName(dataStreamName, 2),
             dataStreamName,
             IndexMode.LOGSDB,
-            metadata.getProject(),
+            project,
             Instant.ofEpochMilli(1L),
             settings,
             List.of()
@@ -695,23 +691,20 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
     public void testGetAdditionalIndexSettingsDowngradeFromSyntheticSourceOldNode() {
         logsdbLicenseService.setSyntheticSourceFallback(true);
         LogsdbIndexModeSettingsProvider provider = withSyntheticSourceDemotionSupport(true, Version.V_8_16_0);
-        Metadata.Builder mb = Metadata.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(
-                List.of(Tuple.tuple(DATA_STREAM_NAME, 1)),
-                List.of(),
-                Instant.now().toEpochMilli(),
-                builder().build(),
-                1
-            ).getMetadata()
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
+            List.of(Tuple.tuple(DATA_STREAM_NAME, 1)),
+            List.of(),
+            Instant.now().toEpochMilli(),
+            builder().build(),
+            1
         );
-        Metadata metadata = mb.build();
         Settings settings = builder().put(IndexSettings.INDEX_MAPPER_SOURCE_MODE_SETTING.getKey(), SourceFieldMapper.Mode.SYNTHETIC)
             .build();
         var result = provider.getAdditionalIndexSettings(
             DataStream.getDefaultBackingIndexName(DATA_STREAM_NAME, 2),
             DATA_STREAM_NAME,
             null,
-            metadata.getProject(),
+            project,
             Instant.ofEpochMilli(1L),
             settings,
             List.of()
@@ -725,21 +718,18 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
         final Settings settings = Settings.EMPTY;
 
         String dataStreamName = DATA_STREAM_NAME;
-        Metadata.Builder mb = Metadata.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(
-                List.of(Tuple.tuple(dataStreamName, 1)),
-                List.of(),
-                Instant.now().toEpochMilli(),
-                builder().build(),
-                1
-            ).getMetadata()
+        ProjectMetadata project = DataStreamTestHelper.getProjectWithDataStreams(
+            List.of(Tuple.tuple(dataStreamName, 1)),
+            List.of(),
+            Instant.now().toEpochMilli(),
+            builder().build(),
+            1
         );
-        Metadata metadata = mb.build();
         Settings result = provider.getAdditionalIndexSettings(
             DataStream.getDefaultBackingIndexName(dataStreamName, 2),
             dataStreamName,
             null,
-            metadata.getProject(),
+            project,
             Instant.ofEpochMilli(1L),
             settings,
             List.of()
@@ -747,22 +737,19 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
         assertThat(result.size(), equalTo(0));
 
         dataStreamName = "logs-app1-0";
-        mb = Metadata.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(
-                List.of(Tuple.tuple(dataStreamName, 1)),
-                List.of(),
-                Instant.now().toEpochMilli(),
-                builder().build(),
-                1
-            ).getMetadata()
+        project = DataStreamTestHelper.getProjectWithDataStreams(
+            List.of(Tuple.tuple(dataStreamName, 1)),
+            List.of(),
+            Instant.now().toEpochMilli(),
+            builder().build(),
+            1
         );
-        metadata = mb.build();
 
         result = provider.getAdditionalIndexSettings(
             DataStream.getDefaultBackingIndexName(dataStreamName, 2),
             dataStreamName,
             null,
-            metadata.getProject(),
+            project,
             Instant.ofEpochMilli(1L),
             settings,
             List.of()
@@ -777,7 +764,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             DataStream.getDefaultBackingIndexName(dataStreamName, 2),
             dataStreamName,
             null,
-            metadata.getProject(),
+            project,
             Instant.ofEpochMilli(1L),
             builder().put(IndexSettings.MODE.getKey(), IndexMode.STANDARD.toString()).build(),
             List.of()
@@ -1156,7 +1143,6 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             """;
 
         String systemIndex = ".security-profile";
-        Metadata metadata = Metadata.EMPTY_METADATA;
         var provider = new LogsdbIndexModeSettingsProvider(
             logsdbLicenseService,
             Settings.builder().put("cluster.logsdb.enabled", true).build()
@@ -1172,7 +1158,7 @@ public class LogsdbIndexModeSettingsProviderTests extends ESTestCase {
             DataStream.getDefaultBackingIndexName(systemIndex, 0),
             systemIndex,
             IndexMode.LOGSDB,
-            metadata.getProject(),
+            emptyProject(),
             Instant.now(),
             settings,
             List.of(new CompressedXContent(mappings))

x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authz/AuthorizedIndicesTests.java

@@ -53,7 +53,7 @@ public class AuthorizedIndicesTests extends ESTestCase {
         AuthorizedIndices authorizedIndices = RBACEngine.resolveAuthorizedIndicesFromRole(
             Role.EMPTY,
             getRequestInfo(""),
-            Metadata.EMPTY_METADATA.getProject().getIndicesLookup(),
+            emptyProject().getIndicesLookup(),
             () -> ignore -> {}
         );
         assertTrue(authorizedIndices.all(IndexComponentSelector.DATA).isEmpty());
@@ -132,7 +132,7 @@ public class AuthorizedIndicesTests extends ESTestCase {
         AuthorizedIndices authorizedIndices = RBACEngine.resolveAuthorizedIndicesFromRole(
             role,
             getRequestInfo(TransportSearchAction.TYPE.name()),
-            Metadata.EMPTY_METADATA.getProject().getIndicesLookup(),
+            emptyProject().getIndicesLookup(),
             () -> ignore -> {}
         );
         assertTrue(authorizedIndices.all(IndexComponentSelector.DATA).isEmpty());
@@ -143,7 +143,7 @@ public class AuthorizedIndicesTests extends ESTestCase {
         AuthorizedIndices authorizedIndices = RBACEngine.resolveAuthorizedIndicesFromRole(
             role,
             getRequestInfo(TransportSearchAction.TYPE.name()),
-            Metadata.EMPTY_METADATA.getProject().getIndicesLookup(),
+            emptyProject().getIndicesLookup(),
             () -> ignore -> {}
         );
         assertTrue(authorizedIndices.all(IndexComponentSelector.DATA).isEmpty());

x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authz/accesscontrol/IndicesPermissionTests.java

@@ -945,16 +945,14 @@ public class IndicesPermissionTests extends ESTestCase {
 
     public void testResourceAuthorizedPredicateForDatastreams() {
         String dataStreamName = "logs-datastream";
-        Metadata.Builder mb = Metadata.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(
-                List.of(Tuple.tuple(dataStreamName, 1)),
-                List.of(),
-                Instant.now().toEpochMilli(),
-                builder().build(),
-                1
-            ).getMetadata()
+        final var project = DataStreamTestHelper.getProjectWithDataStreams(
+            List.of(Tuple.tuple(dataStreamName, 1)),
+            List.of(),
+            Instant.now().toEpochMilli(),
+            builder().build(),
+            1
         );
-        DataStream dataStream = mb.dataStream(dataStreamName);
+        DataStream dataStream = project.dataStreams().get(dataStreamName);
         IndexAbstraction backingIndex = new IndexAbstraction.ConcreteIndex(
             DataStreamTestHelper.createBackingIndex(dataStreamName, 1).build(),
             dataStream
@@ -995,19 +993,17 @@ public class IndicesPermissionTests extends ESTestCase {
             StringMatcher.of(),
             StringMatcher.of("a", "d")
         );
-        Metadata.Builder mb = Metadata.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(
-                List.of(Tuple.tuple("a", 1), Tuple.tuple("b", 1), Tuple.tuple("c", 1), Tuple.tuple("d", 1)),
-                List.of(),
-                Instant.now().toEpochMilli(),
-                builder().build(),
-                1
-            ).getMetadata()
+        final var project = DataStreamTestHelper.getProjectWithDataStreams(
+            List.of(Tuple.tuple("a", 1), Tuple.tuple("b", 1), Tuple.tuple("c", 1), Tuple.tuple("d", 1)),
+            List.of(),
+            Instant.now().toEpochMilli(),
+            builder().build(),
+            1
         );
-        DataStream dataStreamA = mb.dataStream("a");
-        DataStream dataStreamB = mb.dataStream("b");
-        DataStream dataStreamC = mb.dataStream("c");
-        DataStream dataStreamD = mb.dataStream("d");
+        DataStream dataStreamA = project.dataStreams().get("a");
+        DataStream dataStreamB = project.dataStreams().get("b");
+        DataStream dataStreamC = project.dataStreams().get("c");
+        DataStream dataStreamD = project.dataStreams().get("d");
         IndexAbstraction concreteIndexA = concreteIndexAbstraction("a");
         IndexAbstraction concreteIndexB = concreteIndexAbstraction("b");
         IndexAbstraction concreteIndexC = concreteIndexAbstraction("c");
@@ -1034,28 +1030,26 @@ public class IndicesPermissionTests extends ESTestCase {
             StringMatcher.of("a", "f", "g"),
             StringMatcher.of("a", "d")
         );
-        Metadata.Builder mb = Metadata.builder(
-            DataStreamTestHelper.getClusterStateWithDataStreams(
-                List.of(
-                    Tuple.tuple("a", 1),
-                    Tuple.tuple("b", 1),
-                    Tuple.tuple("c", 1),
-                    Tuple.tuple("d", 1),
-                    Tuple.tuple("e", 1),
-                    Tuple.tuple("f", 1)
-                ),
-                List.of(),
-                Instant.now().toEpochMilli(),
-                builder().build(),
-                1
-            ).getMetadata()
+        final var project = DataStreamTestHelper.getProjectWithDataStreams(
+            List.of(
+                Tuple.tuple("a", 1),
+                Tuple.tuple("b", 1),
+                Tuple.tuple("c", 1),
+                Tuple.tuple("d", 1),
+                Tuple.tuple("e", 1),
+                Tuple.tuple("f", 1)
+            ),
+            List.of(),
+            Instant.now().toEpochMilli(),
+            builder().build(),
+            1
         );
-        DataStream dataStreamA = mb.dataStream("a");
-        DataStream dataStreamB = mb.dataStream("b");
-        DataStream dataStreamC = mb.dataStream("c");
-        DataStream dataStreamD = mb.dataStream("d");
-        DataStream dataStreamE = mb.dataStream("e");
-        DataStream dataStreamF = mb.dataStream("f");
+        DataStream dataStreamA = project.dataStreams().get("a");
+        DataStream dataStreamB = project.dataStreams().get("b");
+        DataStream dataStreamC = project.dataStreams().get("c");
+        DataStream dataStreamD = project.dataStreams().get("d");
+        DataStream dataStreamE = project.dataStreams().get("e");
+        DataStream dataStreamF = project.dataStreams().get("f");
         IndexAbstraction concreteIndexA = concreteIndexAbstraction("a");
         IndexAbstraction concreteIndexB = concreteIndexAbstraction("b");
         IndexAbstraction concreteIndexC = concreteIndexAbstraction("c");