From 6e9d93438032a47880b10cae66972549848648ca Mon Sep 17 00:00:00 2001 From: Suyash Choudhary Date: Wed, 13 May 2026 17:03:16 +0530 Subject: [PATCH 1/6] [storagemover] Add scenario tests mirroring .NET source-of-truth (30 methods) Ports the cross-language Storage Mover scenario test suite from azure-sdk-for-net (Azure.ResourceManager.StorageMover/tests/Scenario, 9 files, 30 methods) to the Java SDK. Layout is 1:1 with the .NET source; assertions are adapted to the Java fluent API. Files: - StorageMoverManagementTestBase abstract base, extends ResourceManagerTestProxyTestBase. Provides MultiCloudConnector / AWS S3 well-known IDs from the .NET base, FAKE_STORAGE_ACCOUNT_ID, FIXED_SCHEDULE_START (2030-01-01T00:00:00Z so playback is deterministic and the date serialises with a Z suffix to avoid the RP +00:00 bug documented in the cross-language playbook), generateRandomResourceName, and an assertNotFound helper for the Java-no-Exists-API gap. - AgentTests 1 method, @Disabled (agent VM required) - StorageMoverCollectionTests 1 method - StorageMoverResourceTests 5 methods, 1 @Disabled - ProjectCollectionTests 1 method - ProjectResourceTests 1 method - JobDefinitionJobRunTests 1 method (startJob/stopJob assertThrows ManagementException) - JobDefinitionScheduleTests 3 methods (Weekly / Daily + preservePermissions / Onetime) - JobRunTests 1 method (combined empty list + 404 get) - EndpointTests 16 methods (omnibus + MultiCloudConnector + S3WithHmac activated + 7 valid endpointKind + 5 invalid endpointKind + NfsFileShare). SMB-update identity:None workaround applied per the cross-language playbook. assets.json added with empty Tag; will be populated on first test-proxy push. The pre-existing trivial smoke test StorageMoverManagerTests.java is removed; the README example is hard-coded (not embed-extracted) so this does not affect docs. Compile-checked under Java 21 + Java 8 baseline. All 120 generated mock tests still pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../assets.json | 6 + .../StorageMoverManagerTests.java | 93 ---- .../storagemover/scenario/AgentTests.java | 27 + .../storagemover/scenario/EndpointTests.java | 469 ++++++++++++++++++ .../scenario/JobDefinitionJobRunTests.java | 98 ++++ .../scenario/JobDefinitionScheduleTests.java | 191 +++++++ .../storagemover/scenario/JobRunTests.java | 77 +++ .../scenario/ProjectCollectionTests.java | 53 ++ .../scenario/ProjectResourceTests.java | 42 ++ .../scenario/StorageMoverCollectionTests.java | 85 ++++ .../StorageMoverManagementTestBase.java | 180 +++++++ .../scenario/StorageMoverResourceTests.java | 147 ++++++ 12 files changed, 1375 insertions(+), 93 deletions(-) create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/assets.json delete mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/StorageMoverManagerTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/AgentTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/EndpointTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionJobRunTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobRunTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ProjectCollectionTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ProjectResourceTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverCollectionTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverResourceTests.java diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/assets.json b/sdk/storagemover/azure-resourcemanager-storagemover/assets.json new file mode 100644 index 000000000000..cde93b8b81c4 --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/assets.json @@ -0,0 +1,6 @@ +{ + "AssetsRepo": "Azure/azure-sdk-assets", + "AssetsRepoPrefixPath": "java", + "TagPrefix": "java/storagemover/azure-resourcemanager-storagemover", + "Tag": "" +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/StorageMoverManagerTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/StorageMoverManagerTests.java deleted file mode 100644 index 75939d156abb..000000000000 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/StorageMoverManagerTests.java +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. - -package com.azure.resourcemanager.storagemover; - -import com.azure.core.credential.TokenCredential; -import com.azure.core.http.policy.HttpLogDetailLevel; -import com.azure.core.http.policy.HttpLogOptions; -import com.azure.core.management.AzureEnvironment; -import com.azure.core.management.Region; -import com.azure.core.management.profile.AzureProfile; -import com.azure.core.test.TestProxyTestBase; -import com.azure.core.test.annotation.LiveOnly; -import com.azure.core.util.Configuration; -import com.azure.core.util.CoreUtils; -import com.azure.resourcemanager.resources.ResourceManager; -import com.azure.resourcemanager.resources.fluentcore.policy.ProviderRegistrationPolicy; -import com.azure.resourcemanager.storagemover.models.StorageMover; -import com.azure.resourcemanager.test.utils.TestUtilities; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; - -import java.util.Random; - -public class StorageMoverManagerTests extends TestProxyTestBase { - private static final Random RANDOM = new Random(); - private static final Region REGION = Region.US_EAST2; - private String resourceGroupName = "rg" + randomPadding(); - private StorageMoverManager storageMoverManager; - private ResourceManager resourceManager; - private boolean testEnv; - - @Override - public void beforeTest() { - final TokenCredential credential = TestUtilities.getTokenCredentialForTest(getTestMode()); - final AzureProfile profile = new AzureProfile(AzureEnvironment.AZURE); - - resourceManager = ResourceManager.configure() - .withLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BASIC)) - .authenticate(credential, profile) - .withDefaultSubscription(); - - storageMoverManager = StorageMoverManager.configure() - .withPolicy(new ProviderRegistrationPolicy(resourceManager)) - .withLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BASIC)) - .authenticate(credential, profile); - - // use AZURE_RESOURCE_GROUP_NAME if run in LIVE CI - String testResourceGroup = Configuration.getGlobalConfiguration().get("AZURE_RESOURCE_GROUP_NAME"); - testEnv = !CoreUtils.isNullOrEmpty(testResourceGroup); - if (testEnv) { - resourceGroupName = testResourceGroup; - } else { - resourceManager.resourceGroups().define(resourceGroupName).withRegion(REGION).create(); - } - } - - @Override - protected void afterTest() { - if (!testEnv) { - resourceManager.resourceGroups().beginDeleteByName(resourceGroupName); - } - } - - @Test - @LiveOnly - public void testCreateStorageMover() { - StorageMover storageMover = null; - try { - String moveName = "move" + randomPadding(); - // @embedmeStart - storageMover = storageMoverManager.storageMovers() - .define(moveName) - .withRegion(REGION) - .withExistingResourceGroup(resourceGroupName) - .create(); - // @embedmeEnd - storageMover.refresh(); - Assertions.assertEquals(storageMover.name(), moveName); - Assertions.assertEquals(storageMover.name(), - storageMoverManager.storageMovers().getById(storageMover.id()).name()); - Assertions.assertTrue(storageMoverManager.storageMovers().list().stream().count() > 0); - } finally { - if (storageMover != null) { - storageMoverManager.storageMovers().deleteById(storageMover.id()); - } - } - } - - private static String randomPadding() { - return String.format("%05d", Math.abs(RANDOM.nextInt() % 100000)); - } -} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/AgentTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/AgentTests.java new file mode 100644 index 000000000000..f24c3711b2ce --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/AgentTests.java @@ -0,0 +1,27 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + +/** + * Mirrors {@code AgentTests.cs} from the .NET source-of-truth test suite. + * + *

The single {@code GetExistTest} method is skipped in every language port + * because Storage Mover agents cannot be created via the RP — they self-register + * from a real VM. See {@code storage-mover-scenario-tests-cross-language} task + * note for the rationale shared across .NET, Python, JS, Go, and Java. + */ +public class AgentTests extends StorageMoverManagementTestBase { + + @Test + @Disabled("Agents cannot be created by the RP; this test requires a registered agent VM.") + public void getExist() { + // Body intentionally empty — see @Disabled reason. The .NET reference + // exercises agent get / list / patch (uploadLimitWeeklyRecurrences) on + // a pre-existing agent named "testagent1", which is impossible to set + // up hermetically. + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/EndpointTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/EndpointTests.java new file mode 100644 index 000000000000..812183d1eca6 --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/EndpointTests.java @@ -0,0 +1,469 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.core.management.exception.ManagementException; +import com.azure.resourcemanager.storagemover.models.AzureKeyVaultS3WithHmacCredentials; +import com.azure.resourcemanager.storagemover.models.AzureKeyVaultSmbCredentials; +import com.azure.resourcemanager.storagemover.models.AzureMultiCloudConnectorEndpointProperties; +import com.azure.resourcemanager.storagemover.models.AzureStorageBlobContainerEndpointProperties; +import com.azure.resourcemanager.storagemover.models.AzureStorageNfsFileShareEndpointProperties; +import com.azure.resourcemanager.storagemover.models.AzureStorageSmbFileShareEndpointProperties; +import com.azure.resourcemanager.storagemover.models.Endpoint; +import com.azure.resourcemanager.storagemover.models.EndpointKind; +import com.azure.resourcemanager.storagemover.models.EndpointType; +import com.azure.resourcemanager.storagemover.models.ManagedServiceIdentity; +import com.azure.resourcemanager.storagemover.models.ManagedServiceIdentityType; +import com.azure.resourcemanager.storagemover.models.NfsMountEndpointProperties; +import com.azure.resourcemanager.storagemover.models.S3WithHmacEndpointProperties; +import com.azure.resourcemanager.storagemover.models.S3WithHmacSourceType; +import com.azure.resourcemanager.storagemover.models.SmbMountEndpointProperties; +import com.azure.resourcemanager.storagemover.models.SmbMountEndpointUpdateProperties; +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.stream.StreamSupport; + +/** + * Mirrors {@code EndpointTests.cs} from the .NET source-of-truth (16 methods). + * + *

Each test self-provisions its own storage mover into the per-test resource + * group so tests stay independent. The {@code S3WithHmac} test is intentionally + * activated (the .NET {@code [Ignore]} on it is wrong — placeholder Key Vault / + * S3 URIs are accepted by the RP at metadata level; only running an actual data + * job would need real credentials). + */ +public class EndpointTests extends StorageMoverManagementTestBase { + + // ----------------------------------------------------------------------- + // Omnibus + per-type CRUD + // ----------------------------------------------------------------------- + + @Test + public void createUpdateGetDelete() { + String storageMoverName = createStorageMover("ep-omni"); + + String cEndpointName = generateRandomResourceName("conendpoint-", 24); + String nfsEndpointName = generateRandomResourceName("nfsendpoint-", 24); + String smbEndpointName = generateRandomResourceName("smbendpoint-", 24); + String fsEndpointName = generateRandomResourceName("fsendpoint-", 24); + + // Blob container endpoint. + Endpoint cEndpoint + = storageMoverManager.endpoints() + .define(cEndpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new AzureStorageBlobContainerEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withBlobContainerName("testcontainer") + .withDescription("New container endpoint")) + .create(); + Assertions.assertEquals(cEndpointName, cEndpoint.name()); + Assertions.assertEquals(EndpointType.AZURE_STORAGE_BLOB_CONTAINER, cEndpoint.properties().endpointType()); + + Endpoint cEndpointGet = storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, cEndpointName); + Assertions.assertEquals(cEndpointName, cEndpointGet.name()); + Assertions.assertEquals(EndpointType.AZURE_STORAGE_BLOB_CONTAINER, cEndpointGet.properties().endpointType()); + + // NFS endpoint. + Endpoint nfsEndpoint = storageMoverManager.endpoints() + .define(nfsEndpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new NfsMountEndpointProperties().withHost("10.0.0.1") + .withExport("/") + .withDescription("New NFS endpoint")) + .create(); + Assertions.assertEquals(nfsEndpointName, nfsEndpoint.name()); + Assertions.assertEquals(EndpointType.NFS_MOUNT, nfsEndpoint.properties().endpointType()); + NfsMountEndpointProperties nfsProps = (NfsMountEndpointProperties) nfsEndpoint.properties(); + Assertions.assertEquals("/", nfsProps.export()); + Assertions.assertEquals("10.0.0.1", nfsProps.host()); + + // SMB endpoint with credentials. + AzureKeyVaultSmbCredentials credentials = new AzureKeyVaultSmbCredentials() + .withUsernameUri("https://examples-azureKeyVault.vault.azure.net/secrets/examples-username") + .withPasswordUri("https://examples-azureKeyVault.vault.azure.net/secrets/examples-password"); + Endpoint smbEndpoint = storageMoverManager.endpoints() + .define(smbEndpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new SmbMountEndpointProperties().withHost("10.0.0.1") + .withShareName("testshare") + .withCredentials(credentials) + .withDescription("New Smb mount endpoint")) + .create(); + SmbMountEndpointProperties smbProps = (SmbMountEndpointProperties) smbEndpoint.properties(); + Assertions.assertEquals("https://examples-azureKeyVault.vault.azure.net/secrets/examples-username", + smbProps.credentials().usernameUri()); + Assertions.assertEquals("https://examples-azureKeyVault.vault.azure.net/secrets/examples-password", + smbProps.credentials().passwordUri()); + Assertions.assertEquals("10.0.0.1", smbProps.host()); + Assertions.assertEquals("testshare", smbProps.shareName()); + + // SMB PATCH — workaround: must include identity:{type:None} at top + // level. RP regression in api-version 2025-12-01: PATCH validation + // requires non-null identity for SMB endpoints. See cross-language + // playbook + Storage-XDataMove-RP/src/UserRP/Controllers/EndpointController.cs. + AzureKeyVaultSmbCredentials clearedCredentials + = new AzureKeyVaultSmbCredentials().withUsernameUri("").withPasswordUri(""); + SmbMountEndpointUpdateProperties updateProps + = new SmbMountEndpointUpdateProperties().withCredentials(clearedCredentials) + .withDescription("Update endpoint"); + Endpoint updatedSmb = smbEndpoint.update() + .withIdentity(new ManagedServiceIdentity().withType(ManagedServiceIdentityType.NONE)) + .withProperties(updateProps) + .apply(); + SmbMountEndpointProperties updatedSmbProps = (SmbMountEndpointProperties) updatedSmb.properties(); + Assertions.assertEquals(smbEndpointName, updatedSmb.name()); + Assertions.assertEquals(EndpointType.SMB_MOUNT, updatedSmb.properties().endpointType()); + Assertions.assertEquals("", updatedSmbProps.credentials().passwordUri()); + Assertions.assertEquals("", updatedSmbProps.credentials().usernameUri()); + Assertions.assertEquals("10.0.0.1", updatedSmbProps.host()); + Assertions.assertEquals("testshare", updatedSmbProps.shareName()); + + storageMoverManager.endpoints().delete(resourceGroupName, storageMoverName, smbEndpointName); + + // SMB file share endpoint. + Endpoint fsEndpoint + = storageMoverManager.endpoints() + .define(fsEndpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new AzureStorageSmbFileShareEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withFileShareName("testfileshare") + .withDescription("new file share endpoint")) + .create(); + AzureStorageSmbFileShareEndpointProperties fsProps + = (AzureStorageSmbFileShareEndpointProperties) fsEndpoint.properties(); + Assertions.assertEquals(fsEndpointName, fsEndpoint.name()); + Assertions.assertEquals(EndpointType.AZURE_STORAGE_SMB_FILE_SHARE, fsEndpoint.properties().endpointType()); + Assertions.assertEquals("testfileshare", fsProps.fileShareName()); + Assertions.assertEquals("new file share endpoint", fsProps.description()); + + long count = StreamSupport + .stream(storageMoverManager.endpoints().list(resourceGroupName, storageMoverName).spliterator(), false) + .count(); + Assertions.assertTrue(count > 1, "expected more than one endpoint but found " + count); + + // Existence assertions: positive on c+nfs+fs, negative on smb (deleted) + // and on a never-created name. + Assertions.assertEquals(cEndpointName, + storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, cEndpointName).name()); + assertNotFound( + () -> storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, cEndpointName + "111")); + assertNotFound(() -> storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, smbEndpointName)); + } + + @Test + public void multiCloudConnectorEndpointCreateGetDelete() { + String storageMoverName = createStorageMover("ep-mcc"); + String endpointName = generateRandomResourceName("mcc-", 24); + + AzureMultiCloudConnectorEndpointProperties props + = new AzureMultiCloudConnectorEndpointProperties().withMultiCloudConnectorId(MULTI_CLOUD_CONNECTOR_ID) + .withAwsS3BucketId(AWS_S3_BUCKET_ID) + .withDescription("Test multi-cloud connector endpoint"); + + Endpoint endpoint = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(props) + .create(); + Assertions.assertEquals(endpointName, endpoint.name()); + Assertions.assertEquals(EndpointType.AZURE_MULTI_CLOUD_CONNECTOR, endpoint.properties().endpointType()); + + Endpoint fetched = storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, endpointName); + AzureMultiCloudConnectorEndpointProperties fetchedProps + = (AzureMultiCloudConnectorEndpointProperties) fetched.properties(); + Assertions.assertEquals(endpointName, fetched.name()); + Assertions.assertEquals("Test multi-cloud connector endpoint", fetchedProps.description()); + Assertions.assertNotNull(fetchedProps.multiCloudConnectorId()); + Assertions.assertNotNull(fetchedProps.awsS3BucketId()); + + storageMoverManager.endpoints().delete(resourceGroupName, storageMoverName, endpointName); + assertNotFound(() -> storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, endpointName)); + } + + /** + * Activated despite .NET's {@code [Ignore]}: placeholder S3 / Key Vault URIs + * are accepted by the RP at metadata level; only running a copy job would + * need real credentials. Verified live in the Python port. + */ + @Test + public void s3WithHmacEndpointCreateGetDelete() { + String storageMoverName = createStorageMover("ep-s3"); + String endpointName = generateRandomResourceName("s3hmac-", 24); + + AzureKeyVaultS3WithHmacCredentials credentials = new AzureKeyVaultS3WithHmacCredentials() + .withAccessKeyUri("https://examples-azureKeyVault.vault.azure.net/secrets/examples-accesskey") + .withSecretKeyUri("https://examples-azureKeyVault.vault.azure.net/secrets/examples-secretkey"); + S3WithHmacEndpointProperties props + = new S3WithHmacEndpointProperties().withSourceUri("https://s3.example.com/bucket") + .withSourceType(S3WithHmacSourceType.MINIO) + .withCredentials(credentials) + .withDescription("Test S3 with HMAC endpoint"); + + Endpoint endpoint = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(props) + .create(); + Assertions.assertEquals(endpointName, endpoint.name()); + Assertions.assertEquals(EndpointType.S3WITH_HMAC, endpoint.properties().endpointType()); + + Endpoint fetched = storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, endpointName); + S3WithHmacEndpointProperties fetchedProps = (S3WithHmacEndpointProperties) fetched.properties(); + Assertions.assertEquals(endpointName, fetched.name()); + Assertions.assertEquals("https://s3.example.com/bucket", fetchedProps.sourceUri()); + Assertions.assertEquals(S3WithHmacSourceType.MINIO, fetchedProps.sourceType()); + Assertions.assertEquals("Test S3 with HMAC endpoint", fetchedProps.description()); + Assertions.assertNotNull(fetchedProps.credentials()); + Assertions.assertEquals("https://examples-azureKeyVault.vault.azure.net/secrets/examples-accesskey", + fetchedProps.credentials().accessKeyUri()); + Assertions.assertEquals("https://examples-azureKeyVault.vault.azure.net/secrets/examples-secretkey", + fetchedProps.credentials().secretKeyUri()); + + storageMoverManager.endpoints().delete(resourceGroupName, storageMoverName, endpointName); + assertNotFound(() -> storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, endpointName)); + } + + @Test + public void nfsFileShareEndpointCreateGetDelete() { + String storageMoverName = createStorageMover("ep-nfsfs"); + String endpointName = generateRandomResourceName("nfsfs-", 24); + + AzureStorageNfsFileShareEndpointProperties props + = new AzureStorageNfsFileShareEndpointProperties().withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withFileShareName("testnfsfileshare") + .withDescription("Test NFS file share endpoint"); + + Endpoint endpoint = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(props) + .create(); + Assertions.assertEquals(endpointName, endpoint.name()); + Assertions.assertEquals(EndpointType.AZURE_STORAGE_NFS_FILE_SHARE, endpoint.properties().endpointType()); + + Endpoint fetched = storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, endpointName); + AzureStorageNfsFileShareEndpointProperties fetchedProps + = (AzureStorageNfsFileShareEndpointProperties) fetched.properties(); + Assertions.assertEquals(endpointName, fetched.name()); + Assertions.assertEquals("testnfsfileshare", fetchedProps.fileShareName()); + Assertions.assertEquals("Test NFS file share endpoint", fetchedProps.description()); + Assertions.assertNotNull(fetchedProps.storageAccountResourceId()); + + storageMoverManager.endpoints().delete(resourceGroupName, storageMoverName, endpointName); + assertNotFound(() -> storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, endpointName)); + } + + // ----------------------------------------------------------------------- + // EndpointKind validation — valid combinations should succeed + // ----------------------------------------------------------------------- + + @Test + public void nfsMountEndpointKindSourceSucceeds() { + String storageMoverName = createStorageMover("ek-nfs-src"); + String endpointName = generateRandomResourceName("nfs-src-", 24); + Endpoint endpoint = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new NfsMountEndpointProperties().withHost("10.0.0.1") + .withExport("/") + .withDescription("NFS source endpoint") + .withEndpointKind(EndpointKind.SOURCE)) + .create(); + Assertions.assertEquals(EndpointKind.SOURCE, endpoint.properties().endpointKind()); + } + + @Test + public void smbMountEndpointKindSourceSucceeds() { + String storageMoverName = createStorageMover("ek-smb-src"); + String endpointName = generateRandomResourceName("smb-src-", 24); + Endpoint endpoint = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new SmbMountEndpointProperties().withHost("10.0.0.1") + .withShareName("testshare") + .withDescription("SMB source endpoint") + .withEndpointKind(EndpointKind.SOURCE)) + .create(); + Assertions.assertEquals(EndpointKind.SOURCE, endpoint.properties().endpointKind()); + } + + @Test + public void multiCloudConnectorEndpointKindSourceSucceeds() { + String storageMoverName = createStorageMover("ek-mcc-src"); + String endpointName = generateRandomResourceName("mcc-src-", 24); + Endpoint endpoint = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties( + new AzureMultiCloudConnectorEndpointProperties().withMultiCloudConnectorId(MULTI_CLOUD_CONNECTOR_ID) + .withAwsS3BucketId(AWS_S3_BUCKET_ID) + .withDescription("Multi-cloud connector source endpoint") + .withEndpointKind(EndpointKind.SOURCE)) + .create(); + Assertions.assertEquals(EndpointKind.SOURCE, endpoint.properties().endpointKind()); + } + + @Test + public void blobContainerEndpointKindSourceSucceeds() { + String storageMoverName = createStorageMover("ek-blob-src"); + String endpointName = generateRandomResourceName("blob-src-", 24); + Endpoint endpoint + = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new AzureStorageBlobContainerEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withBlobContainerName("testcontainer") + .withDescription("Blob container source endpoint") + .withEndpointKind(EndpointKind.SOURCE)) + .create(); + Assertions.assertEquals(EndpointKind.SOURCE, endpoint.properties().endpointKind()); + } + + @Test + public void blobContainerEndpointKindTargetSucceeds() { + String storageMoverName = createStorageMover("ek-blob-tgt"); + String endpointName = generateRandomResourceName("blob-tgt-", 24); + Endpoint endpoint + = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new AzureStorageBlobContainerEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withBlobContainerName("testcontainer") + .withDescription("Blob container target endpoint") + .withEndpointKind(EndpointKind.TARGET)) + .create(); + Assertions.assertEquals(EndpointKind.TARGET, endpoint.properties().endpointKind()); + } + + @Test + public void smbFileShareEndpointKindTargetSucceeds() { + String storageMoverName = createStorageMover("ek-smbfs-tgt"); + String endpointName = generateRandomResourceName("smbfs-tgt-", 24); + Endpoint endpoint + = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new AzureStorageSmbFileShareEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withFileShareName("testfileshare") + .withDescription("SMB file share target endpoint") + .withEndpointKind(EndpointKind.TARGET)) + .create(); + Assertions.assertEquals(EndpointKind.TARGET, endpoint.properties().endpointKind()); + } + + @Test + public void nfsFileShareEndpointKindTargetSucceeds() { + String storageMoverName = createStorageMover("ek-nfsfs-tgt"); + String endpointName = generateRandomResourceName("nfsfs-tgt-", 24); + Endpoint endpoint + = storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new AzureStorageNfsFileShareEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withFileShareName("testnfsfileshare") + .withDescription("NFS file share target endpoint") + .withEndpointKind(EndpointKind.TARGET)) + .create(); + Assertions.assertEquals(EndpointKind.TARGET, endpoint.properties().endpointKind()); + } + + // ----------------------------------------------------------------------- + // EndpointKind validation — invalid combinations must fail + // ----------------------------------------------------------------------- + + @Test + public void nfsMountEndpointKindTargetFails() { + String storageMoverName = createStorageMover("ek-nfs-tgt-fail"); + String endpointName = generateRandomResourceName("nfs-tgt-", 24); + Assertions.assertThrows(ManagementException.class, + () -> storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new NfsMountEndpointProperties().withHost("10.0.0.1") + .withExport("/") + .withEndpointKind(EndpointKind.TARGET)) + .create()); + } + + @Test + public void smbMountEndpointKindTargetFails() { + String storageMoverName = createStorageMover("ek-smb-tgt-fail"); + String endpointName = generateRandomResourceName("smb-tgt-", 24); + Assertions.assertThrows(ManagementException.class, + () -> storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new SmbMountEndpointProperties().withHost("10.0.0.1") + .withShareName("testshare") + .withEndpointKind(EndpointKind.TARGET)) + .create()); + } + + @Test + public void multiCloudConnectorEndpointKindTargetFails() { + String storageMoverName = createStorageMover("ek-mcc-tgt-fail"); + String endpointName = generateRandomResourceName("mcc-tgt-", 24); + Assertions + .assertThrows(ManagementException.class, + () -> storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new AzureMultiCloudConnectorEndpointProperties() + .withMultiCloudConnectorId(MULTI_CLOUD_CONNECTOR_ID) + .withAwsS3BucketId(AWS_S3_BUCKET_ID) + .withEndpointKind(EndpointKind.TARGET)) + .create()); + } + + @Test + public void smbFileShareEndpointKindSourceFails() { + String storageMoverName = createStorageMover("ek-smbfs-src-fail"); + String endpointName = generateRandomResourceName("smbfs-src-", 24); + Assertions.assertThrows(ManagementException.class, + () -> storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new AzureStorageSmbFileShareEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withFileShareName("testfileshare") + .withEndpointKind(EndpointKind.SOURCE)) + .create()); + } + + @Test + public void nfsFileShareEndpointKindSourceFails() { + String storageMoverName = createStorageMover("ek-nfsfs-src-fail"); + String endpointName = generateRandomResourceName("nfsfs-src-", 24); + Assertions.assertThrows(ManagementException.class, + () -> storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(new AzureStorageNfsFileShareEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withFileShareName("testnfsfileshare") + .withEndpointKind(EndpointKind.SOURCE)) + .create()); + } + + // ----------------------------------------------------------------------- + // Helpers + // ----------------------------------------------------------------------- + + private String createStorageMover(String prefix) { + StorageMover sm = storageMoverManager.storageMovers() + .define(generateRandomResourceName("sm-" + prefix + "-", 24)) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .create(); + return sm.name(); + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionJobRunTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionJobRunTests.java new file mode 100644 index 000000000000..22954e494800 --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionJobRunTests.java @@ -0,0 +1,98 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.core.management.exception.ManagementException; +import com.azure.resourcemanager.storagemover.models.AzureStorageBlobContainerEndpointProperties; +import com.azure.resourcemanager.storagemover.models.CopyMode; +import com.azure.resourcemanager.storagemover.models.Endpoint; +import com.azure.resourcemanager.storagemover.models.JobDefinition; +import com.azure.resourcemanager.storagemover.models.NfsMountEndpointProperties; +import com.azure.resourcemanager.storagemover.models.Project; +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.stream.StreamSupport; + +/** + * Mirrors {@code JobDefinitionJobRunTests.cs} from the .NET source-of-truth. + * + *

Self-provisions storage mover, project, source endpoint (NFS) and target + * endpoint (Blob), creates a job definition, and verifies CRUD behaviour. The + * final {@code startJob}/{@code stopJob} calls are expected to fail with a + * {@link ManagementException} because no agent is registered against the + * storage mover — see the cross-language playbook. + */ +public class JobDefinitionJobRunTests extends StorageMoverManagementTestBase { + + @Test + public void jobDefinitionJobRun() { + String storageMoverName = generateRandomResourceName("stomover-", 24); + String projectName = generateRandomResourceName("project-", 24); + String sourceEndpointName = generateRandomResourceName("nfsep-", 24); + String targetEndpointName = generateRandomResourceName("blobep-", 24); + String jobDefinitionName = generateRandomResourceName("jobdef-", 24); + + StorageMover sm = storageMoverManager.storageMovers() + .define(storageMoverName) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .create(); + + Project project = storageMoverManager.projects() + .define(projectName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .create(); + + Endpoint nfsEndpoint = storageMoverManager.endpoints() + .define(sourceEndpointName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties(new NfsMountEndpointProperties().withHost("10.0.0.1").withExport("/")) + .create(); + + Endpoint blobEndpoint + = storageMoverManager.endpoints() + .define(targetEndpointName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties(new AzureStorageBlobContainerEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withBlobContainerName("testcontainer")) + .create(); + + JobDefinition jobDefinition = storageMoverManager.jobDefinitions() + .define(jobDefinitionName) + .withExistingProject(resourceGroupName, sm.name(), project.name()) + .withCopyMode(CopyMode.ADDITIVE) + .withSourceName(nfsEndpoint.name()) + .withTargetName(blobEndpoint.name()) + .create(); + Assertions.assertEquals(jobDefinitionName, jobDefinition.name()); + Assertions.assertEquals(blobEndpoint.name(), jobDefinition.targetName()); + Assertions.assertEquals(nfsEndpoint.name(), jobDefinition.sourceName()); + Assertions.assertEquals(CopyMode.ADDITIVE, jobDefinition.copyMode()); + + JobDefinition fetched + = storageMoverManager.jobDefinitions().get(resourceGroupName, sm.name(), project.name(), jobDefinitionName); + Assertions.assertEquals(jobDefinitionName, fetched.name()); + + long count = StreamSupport.stream( + storageMoverManager.jobDefinitions().list(resourceGroupName, sm.name(), project.name()).spliterator(), + false).count(); + Assertions.assertTrue(count >= 1, "expected at least one job definition but found " + count); + + // Equivalence between collection-get and resource-self-refresh. + JobDefinition refreshed = jobDefinition.refresh(); + Assertions.assertEquals(jobDefinition.name(), refreshed.name()); + Assertions.assertEquals(jobDefinition.targetName(), refreshed.targetName()); + Assertions.assertEquals(jobDefinition.agentName(), refreshed.agentName()); + Assertions.assertEquals(jobDefinition.sourceName(), refreshed.sourceName()); + Assertions.assertEquals(jobDefinition.id(), refreshed.id()); + + // StartJob / StopJob require a registered agent — without one the RP + // returns a 4xx wrapped in ManagementException. + Assertions.assertThrows(ManagementException.class, jobDefinition::startJob); + Assertions.assertThrows(ManagementException.class, jobDefinition::stopJob); + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java new file mode 100644 index 000000000000..16cb23264ae3 --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java @@ -0,0 +1,191 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.resourcemanager.storagemover.models.AzureStorageBlobContainerEndpointProperties; +import com.azure.resourcemanager.storagemover.models.CopyMode; +import com.azure.resourcemanager.storagemover.models.DataIntegrityValidation; +import com.azure.resourcemanager.storagemover.models.Endpoint; +import com.azure.resourcemanager.storagemover.models.Frequency; +import com.azure.resourcemanager.storagemover.models.JobDefinition; +import com.azure.resourcemanager.storagemover.models.NfsMountEndpointProperties; +import com.azure.resourcemanager.storagemover.models.Project; +import com.azure.resourcemanager.storagemover.models.ScheduleInfo; +import com.azure.resourcemanager.storagemover.models.SchedulerTime; +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.Collections; + +/** + * Mirrors {@code JobDefinitionScheduleTests.cs} from the .NET source-of-truth. + * + *

All schedule {@code startDate}/{@code endDate} values are derived from + * {@link #FIXED_SCHEDULE_START} (a fixed far-future {@code Z}-offset + * {@code OffsetDateTime}) so playback recordings stay deterministic and the + * server does not see the {@code +00:00}-suffix that triggers an RP bug — see + * the cross-language playbook. + */ +public class JobDefinitionScheduleTests extends StorageMoverManagementTestBase { + + @Test + public void createJobDefinitionWithWeeklySchedule() { + TestContext ctx = provisionParents(); + String jobDefinitionName = generateRandomResourceName("jobdef-sched-", 24); + + ScheduleInfo schedule = new ScheduleInfo().withFrequency(Frequency.WEEKLY) + .withIsActive(true) + .withExecutionTime(new SchedulerTime().withHour(2)) + .withStartDate(FIXED_SCHEDULE_START) + .withEndDate(FIXED_SCHEDULE_START.plusDays(30)) + .withDaysOfWeek(Arrays.asList("Monday", "Wednesday", "Friday")); + + JobDefinition jobDefinition = storageMoverManager.jobDefinitions() + .define(jobDefinitionName) + .withExistingProject(resourceGroupName, ctx.storageMoverName, ctx.projectName) + .withCopyMode(CopyMode.ADDITIVE) + .withSourceName(ctx.sourceName) + .withTargetName(ctx.targetName) + .withDescription("Job definition with weekly schedule") + .withDataIntegrityValidation(DataIntegrityValidation.SAVE_VERIFY_FILE_MD5) + .withSchedule(schedule) + .create(); + + Assertions.assertEquals(jobDefinitionName, jobDefinition.name()); + Assertions.assertEquals(ctx.sourceName, jobDefinition.sourceName()); + Assertions.assertEquals(ctx.targetName, jobDefinition.targetName()); + Assertions.assertEquals(CopyMode.ADDITIVE, jobDefinition.copyMode()); + Assertions.assertEquals("Job definition with weekly schedule", jobDefinition.description()); + + Assertions.assertNotNull(jobDefinition.schedule()); + Assertions.assertEquals(Frequency.WEEKLY, jobDefinition.schedule().frequency()); + Assertions.assertEquals(Boolean.TRUE, jobDefinition.schedule().isActive()); + Assertions.assertEquals(2, jobDefinition.schedule().executionTime().hour()); + Assertions.assertEquals(3, jobDefinition.schedule().daysOfWeek().size()); + + JobDefinition refetched = storageMoverManager.jobDefinitions() + .get(resourceGroupName, ctx.storageMoverName, ctx.projectName, jobDefinitionName); + Assertions.assertEquals(jobDefinitionName, refetched.name()); + Assertions.assertNotNull(refetched.schedule()); + Assertions.assertEquals(Frequency.WEEKLY, refetched.schedule().frequency()); + + storageMoverManager.jobDefinitions() + .delete(resourceGroupName, ctx.storageMoverName, ctx.projectName, jobDefinitionName); + assertNotFound(() -> storageMoverManager.jobDefinitions() + .get(resourceGroupName, ctx.storageMoverName, ctx.projectName, jobDefinitionName)); + } + + @Test + public void createJobDefinitionWithDailyScheduleAndPreservePermissions() { + TestContext ctx = provisionParents(); + String jobDefinitionName = generateRandomResourceName("jobdef-daily-", 24); + + ScheduleInfo schedule = new ScheduleInfo().withFrequency(Frequency.DAILY) + .withIsActive(true) + .withExecutionTime(new SchedulerTime().withHour(0)) + .withStartDate(FIXED_SCHEDULE_START) + .withEndDate(FIXED_SCHEDULE_START.plusDays(30)); + + JobDefinition jobDefinition = storageMoverManager.jobDefinitions() + .define(jobDefinitionName) + .withExistingProject(resourceGroupName, ctx.storageMoverName, ctx.projectName) + .withCopyMode(CopyMode.MIRROR) + .withSourceName(ctx.sourceName) + .withTargetName(ctx.targetName) + .withDescription("Job definition with daily schedule") + .withDataIntegrityValidation(DataIntegrityValidation.NONE) + .withPreservePermissions(true) + .withSchedule(schedule) + .create(); + + Assertions.assertEquals(jobDefinitionName, jobDefinition.name()); + Assertions.assertEquals(CopyMode.MIRROR, jobDefinition.copyMode()); + Assertions.assertNotNull(jobDefinition.schedule()); + Assertions.assertEquals(Frequency.DAILY, jobDefinition.schedule().frequency()); + Assertions.assertEquals(Boolean.TRUE, jobDefinition.schedule().isActive()); + + storageMoverManager.jobDefinitions() + .delete(resourceGroupName, ctx.storageMoverName, ctx.projectName, jobDefinitionName); + } + + @Test + public void createJobDefinitionWithOnetimeSchedule() { + TestContext ctx = provisionParents(); + String jobDefinitionName = generateRandomResourceName("jobdef-once-", 24); + + // Onetime is the only frequency that may omit endDate. + ScheduleInfo schedule = new ScheduleInfo().withFrequency(Frequency.ONETIME) + .withIsActive(true) + .withExecutionTime(new SchedulerTime().withHour(10)) + .withStartDate(FIXED_SCHEDULE_START) + .withDaysOfWeek(Collections.emptyList()); + + JobDefinition jobDefinition = storageMoverManager.jobDefinitions() + .define(jobDefinitionName) + .withExistingProject(resourceGroupName, ctx.storageMoverName, ctx.projectName) + .withCopyMode(CopyMode.ADDITIVE) + .withSourceName(ctx.sourceName) + .withTargetName(ctx.targetName) + .withDescription("Job definition with one-time schedule") + .withSchedule(schedule) + .create(); + + Assertions.assertEquals(jobDefinitionName, jobDefinition.name()); + Assertions.assertNotNull(jobDefinition.schedule()); + Assertions.assertEquals(Frequency.ONETIME, jobDefinition.schedule().frequency()); + Assertions.assertEquals(Boolean.TRUE, jobDefinition.schedule().isActive()); + + storageMoverManager.jobDefinitions() + .delete(resourceGroupName, ctx.storageMoverName, ctx.projectName, jobDefinitionName); + } + + private TestContext provisionParents() { + TestContext ctx = new TestContext(); + ctx.storageMoverName = generateRandomResourceName("stomover-sched-", 24); + ctx.projectName = generateRandomResourceName("project-sched-", 24); + ctx.sourceName = generateRandomResourceName("nfsep-", 24); + ctx.targetName = generateRandomResourceName("blobep-", 24); + + StorageMover sm = storageMoverManager.storageMovers() + .define(ctx.storageMoverName) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .create(); + + Project project = storageMoverManager.projects() + .define(ctx.projectName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .create(); + + Endpoint sourceEndpoint = storageMoverManager.endpoints() + .define(ctx.sourceName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties(new NfsMountEndpointProperties().withHost("10.0.0.1").withExport("/")) + .create(); + + Endpoint targetEndpoint + = storageMoverManager.endpoints() + .define(ctx.targetName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties(new AzureStorageBlobContainerEndpointProperties() + .withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withBlobContainerName("testcontainer")) + .create(); + + // Reference the created resources to avoid unused-variable warnings. + Assertions.assertNotNull(project); + Assertions.assertNotNull(sourceEndpoint); + Assertions.assertNotNull(targetEndpoint); + return ctx; + } + + private static final class TestContext { + String storageMoverName; + String projectName; + String sourceName; + String targetName; + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobRunTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobRunTests.java new file mode 100644 index 000000000000..c8f28466b257 --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobRunTests.java @@ -0,0 +1,77 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.resourcemanager.storagemover.models.AzureStorageBlobContainerEndpointProperties; +import com.azure.resourcemanager.storagemover.models.CopyMode; +import com.azure.resourcemanager.storagemover.models.JobDefinition; +import com.azure.resourcemanager.storagemover.models.NfsMountEndpointProperties; +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.stream.StreamSupport; + +/** + * Mirrors {@code JobRunTests.cs} from the .NET source-of-truth. + * + *

Without a registered agent no JobRun ever materializes against a job + * definition, so the .NET test's "get an existing job run" assertion is + * impossible to satisfy hermetically. Per the cross-language playbook (Python's + * final state) this collapses to two assertions on a freshly created job + * definition: the job-run list is empty AND a get of an arbitrary jobName + * returns 404. + */ +public class JobRunTests extends StorageMoverManagementTestBase { + + @Test + public void getExist() { + String storageMoverName = generateRandomResourceName("stomover-jr-", 24); + String projectName = generateRandomResourceName("project-jr-", 24); + String sourceEndpointName = generateRandomResourceName("nfsep-", 24); + String targetEndpointName = generateRandomResourceName("blobep-", 24); + String jobDefinitionName = generateRandomResourceName("jobdef-jr-", 24); + // Constant from the .NET base class — any well-formed name works since + // we only use it for the negative get-by-name path. + String missingJobName = "6e8c0dfe-821a-427d-8d11-a9ed7f1c9c13"; + + StorageMover sm = storageMoverManager.storageMovers() + .define(storageMoverName) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .create(); + storageMoverManager.projects() + .define(projectName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .create(); + storageMoverManager.endpoints() + .define(sourceEndpointName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties(new NfsMountEndpointProperties().withHost("10.0.0.1").withExport("/")) + .create(); + storageMoverManager.endpoints() + .define(targetEndpointName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties( + new AzureStorageBlobContainerEndpointProperties().withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withBlobContainerName("testcontainer")) + .create(); + JobDefinition jobDefinition = storageMoverManager.jobDefinitions() + .define(jobDefinitionName) + .withExistingProject(resourceGroupName, sm.name(), projectName) + .withCopyMode(CopyMode.ADDITIVE) + .withSourceName(sourceEndpointName) + .withTargetName(targetEndpointName) + .create(); + Assertions.assertNotNull(jobDefinition); + + long count = StreamSupport.stream(storageMoverManager.jobRuns() + .list(resourceGroupName, sm.name(), projectName, jobDefinitionName) + .spliterator(), false).count(); + Assertions.assertEquals(0L, count, "no JobRun should exist without a registered agent"); + + assertNotFound(() -> storageMoverManager.jobRuns() + .get(resourceGroupName, sm.name(), projectName, jobDefinitionName, missingJobName)); + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ProjectCollectionTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ProjectCollectionTests.java new file mode 100644 index 000000000000..7c1af521717f --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ProjectCollectionTests.java @@ -0,0 +1,53 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.resourcemanager.storagemover.models.Project; +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.stream.StreamSupport; + +/** + * Mirrors {@code ProjectCollectionTests.cs} from the .NET source-of-truth. + * The .NET method name carries a typo ({@code CrateGetExistTest}); the Java + * port spells it {@code createGetExist}. + */ +public class ProjectCollectionTests extends StorageMoverManagementTestBase { + + @Test + public void createGetExist() { + String storageMoverName = generateRandomResourceName("stomover-", 24); + StorageMover storageMover = storageMoverManager.storageMovers() + .define(storageMoverName) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .create(); + Assertions.assertEquals(storageMoverName, storageMover.name()); + + String projectName = generateRandomResourceName("project-", 24); + Project created = storageMoverManager.projects() + .define(projectName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .create(); + Assertions.assertEquals(projectName, created.name()); + Assertions.assertNull(created.description()); + Assertions.assertEquals("microsoft.storagemover/storagemovers/projects", created.type().toLowerCase()); + + Project fetched = storageMoverManager.projects().get(resourceGroupName, storageMoverName, projectName); + Assertions.assertEquals(projectName, fetched.name()); + Assertions.assertNull(fetched.description()); + Assertions.assertEquals("microsoft.storagemover/storagemovers/projects", fetched.type().toLowerCase()); + + long count = StreamSupport + .stream(storageMoverManager.projects().list(resourceGroupName, storageMoverName).spliterator(), false) + .count(); + Assertions.assertTrue(count >= 1, "expected at least one project but found " + count); + + // Existence positive case — get must succeed. + Assertions.assertEquals(projectName, + storageMoverManager.projects().get(resourceGroupName, storageMoverName, projectName).name()); + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ProjectResourceTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ProjectResourceTests.java new file mode 100644 index 000000000000..6db32585ed7b --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ProjectResourceTests.java @@ -0,0 +1,42 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.resourcemanager.storagemover.models.Project; +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +/** + * Mirrors {@code ProjectResourceTests.cs} from the .NET source-of-truth. + */ +public class ProjectResourceTests extends StorageMoverManagementTestBase { + + @Test + public void getUpdateDelete() { + String storageMoverName = generateRandomResourceName("stomover-", 24); + StorageMover storageMover = storageMoverManager.storageMovers() + .define(storageMoverName) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .create(); + + String projectName = generateRandomResourceName("project-", 24); + Project created = storageMoverManager.projects() + .define(projectName) + .withExistingStorageMover(resourceGroupName, storageMover.name()) + .create(); + + Project fetched = storageMoverManager.projects().get(resourceGroupName, storageMover.name(), projectName); + Assertions.assertEquals(created.name(), fetched.name()); + Assertions.assertEquals(created.description(), fetched.description()); + Assertions.assertEquals(created.id(), fetched.id()); + + Project updated = fetched.update().withDescription("This is an updated project").apply(); + Assertions.assertEquals("This is an updated project", updated.description()); + + storageMoverManager.projects().delete(resourceGroupName, storageMover.name(), projectName); + assertNotFound(() -> storageMoverManager.projects().get(resourceGroupName, storageMover.name(), projectName)); + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverCollectionTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverCollectionTests.java new file mode 100644 index 000000000000..2432bdb4bfe0 --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverCollectionTests.java @@ -0,0 +1,85 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.stream.StreamSupport; + +/** + * Mirrors {@code StorageMoverCollectionTests.cs} from the .NET source-of-truth + * test suite. + */ +public class StorageMoverCollectionTests extends StorageMoverManagementTestBase { + + @Test + public void createUpdateGetExists() { + String storageMoverName1 = generateRandomResourceName("testsm-", 24); + String storageMoverName2 = generateRandomResourceName("testsm-", 24); + + Map tags = new HashMap<>(); + tags.put("tag1", "value1"); + + StorageMover sm1 = storageMoverManager.storageMovers() + .define(storageMoverName1) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .withTags(tags) + .withDescription("This is a new storage mover") + .create(); + Assertions.assertEquals(storageMoverName1, sm1.name()); + Assertions.assertEquals("value1", sm1.tags().get("tag1")); + Assertions.assertEquals("This is a new storage mover", sm1.description()); + + StorageMover sm2 = storageMoverManager.storageMovers() + .define(storageMoverName2) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .withTags(tags) + .withDescription("This is a new storage mover") + .create(); + Assertions.assertEquals(storageMoverName2, sm2.name()); + + StorageMover fetched + = storageMoverManager.storageMovers().getByResourceGroup(resourceGroupName, storageMoverName1); + Assertions.assertEquals(storageMoverName1, fetched.name()); + Assertions.assertEquals("value1", fetched.tags().get("tag1")); + Assertions.assertEquals("This is a new storage mover", fetched.description()); + + long count = StreamSupport + .stream(storageMoverManager.storageMovers().listByResourceGroup(resourceGroupName).spliterator(), false) + .count(); + Assertions.assertEquals(2L, count); + + StorageMover updated = fetched.update().withDescription("This is an updated storage mover").apply(); + Assertions.assertEquals(storageMoverName1, updated.name()); + Assertions.assertEquals("value1", updated.tags().get("tag1")); + Assertions.assertEquals("This is an updated storage mover", updated.description()); + + // Existence check — Java SDK has no Exists helper, so we verify presence + // via getByResourceGroup and absence via assertNotFound (404 wrapped in + // ManagementException). + Assertions.assertEquals(storageMoverName1, + storageMoverManager.storageMovers().getByResourceGroup(resourceGroupName, storageMoverName1).name()); + assertNotFound( + () -> storageMoverManager.storageMovers().getByResourceGroup(resourceGroupName, storageMoverName1 + "111")); + } + + @SuppressWarnings("unused") + private static long count(Iterable iterable) { + // Helper intentionally left in case future tests want to count without + // depending on Stream — avoids importing StreamSupport everywhere. + return StreamSupport.stream(iterable.spliterator(), false).count(); + } + + @SuppressWarnings("unused") + private static Map emptyTags() { + return Collections.emptyMap(); + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java new file mode 100644 index 000000000000..7857d57b385b --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java @@ -0,0 +1,180 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.core.credential.TokenCredential; +import com.azure.core.http.HttpClient; +import com.azure.core.http.HttpPipeline; +import com.azure.core.http.policy.HttpLogOptions; +import com.azure.core.http.policy.HttpPipelinePolicy; +import com.azure.core.http.policy.RetryPolicy; +import com.azure.core.management.Region; +import com.azure.core.management.exception.ManagementException; +import com.azure.core.management.profile.AzureProfile; +import com.azure.core.util.Configuration; +import com.azure.core.util.CoreUtils; +import com.azure.resourcemanager.resources.ResourceManager; +import com.azure.resourcemanager.resources.fluentcore.policy.ProviderRegistrationPolicy; +import com.azure.resourcemanager.resources.fluentcore.utils.HttpPipelineProvider; +import com.azure.resourcemanager.resources.fluentcore.utils.ResourceManagerUtils; +import com.azure.resourcemanager.resources.models.ResourceGroup; +import com.azure.resourcemanager.storagemover.StorageMoverManager; +import com.azure.resourcemanager.test.ResourceManagerTestProxyTestBase; +import com.azure.resourcemanager.test.utils.TestDelayProvider; +import org.junit.jupiter.api.Assertions; + +import java.time.OffsetDateTime; +import java.time.temporal.ChronoUnit; +import java.util.ArrayList; +import java.util.List; + +/** + * Base class for Storage Mover scenario tests. + * + *

Mirrors the cross-language test suite layout used by .NET + * ({@code Azure.ResourceManager.StorageMover/tests/Scenario}) and Python + * ({@code azure-mgmt-storagemover/tests}). Each concrete subclass focuses on + * one operation group. + */ +public abstract class StorageMoverManagementTestBase extends ResourceManagerTestProxyTestBase { + + /** + * Default region. Overridable via {@code AZURE_TEST_LOCATION} (e.g. when a + * subscription does not have {@code eastus} enabled). + */ + protected static final Region DEFAULT_REGION + = parseRegionOrDefault(Configuration.getGlobalConfiguration().get("AZURE_TEST_LOCATION"), Region.US_EAST); + + /** + * Fixed schedule {@code startDate} used across schedule tests. + * + *

Java's test-proxy does not have a {@code Recording.Now} equivalent; using + * {@code OffsetDateTime.now()} would produce a different timestamp on every + * run and break playback. The value uses {@code Z} offset suffix (not + * {@code +00:00}) to avoid an RP serialization bug documented in the + * cross-language playbook. + */ + protected static final OffsetDateTime FIXED_SCHEDULE_START = OffsetDateTime.parse("2030-01-01T00:00:00Z"); + + /** + * Well-known resource ids used by the {@code AzureMultiCloudConnector} + * endpoint scenarios. Mirrors the constants in + * {@code StorageMoverManagementTestBase.cs} from .NET. + */ + protected static final String MULTI_CLOUD_CONNECTOR_ID + = "/subscriptions/b6b34ad8-ca89-4f85-beb7-c2ec13702dac/resourceGroups/E2E-Management-RGsyn" + + "/providers/Microsoft.HybridConnectivity/publicCloudConnectors/e2e-sm-rp-connector"; + + protected static final String AWS_S3_BUCKET_ID + = "/subscriptions/b6b34ad8-ca89-4f85-beb7-c2ec13702dac/resourceGroups/aws_640698235822" + + "/providers/Microsoft.AWSConnector/s3Buckets/e2e-sm-rp-bucket"; + + /** + * Placeholder storage account resource id used when an endpoint requires a + * storage-account ARM id but the test does not actually hit the storage + * account. The Storage Mover RP accepts any well-formed id at endpoint + * metadata level. + */ + protected static final String FAKE_STORAGE_ACCOUNT_ID + = "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/fakeRg" + + "/providers/Microsoft.Storage/storageAccounts/fakeaccount"; + + protected StorageMoverManager storageMoverManager; + protected ResourceManager resourceManager; + protected String resourceGroupName; + + /** + * Provider registration policy. Has to be a member field because the + * pipeline (and therefore the policy) must exist before the + * {@link ResourceManager} that supplies the provider list does — see the + * two-phase wiring in {@link #buildHttpPipeline} / {@link #initializeClients}. + */ + private final ProviderRegistrationPolicy providerRegistrationPolicy = new ProviderRegistrationPolicy(); + + @Override + protected HttpPipeline buildHttpPipeline(TokenCredential credential, AzureProfile profile, + HttpLogOptions httpLogOptions, List policies, HttpClient httpClient) { + List mergedPolicies = new ArrayList<>(); + if (policies != null) { + mergedPolicies.addAll(policies); + } + // Without auto-registration the first call against a fresh subscription + // returns "MissingSubscriptionRegistration". + mergedPolicies.add(providerRegistrationPolicy); + return HttpPipelineProvider.buildHttpPipeline(credential, profile, null, httpLogOptions, null, + new RetryPolicy("Retry-After", ChronoUnit.SECONDS), mergedPolicies, httpClient); + } + + @Override + protected void initializeClients(HttpPipeline httpPipeline, AzureProfile profile) { + ResourceManagerUtils.InternalRuntimeContext.setDelayProvider(new TestDelayProvider(!isPlaybackMode())); + + // StorageMoverManager has no public 2-arg constructor, so the generic + // buildManager() helper from the base does not work — use the static + // authenticate factory instead. + storageMoverManager = StorageMoverManager.authenticate(httpPipeline, profile); + resourceManager = ResourceManager.authenticate(httpPipeline, profile).withDefaultSubscription(); + + // Now that ResourceManager exists we can hand its provider collection to + // the policy that was already wired into the pipeline. + providerRegistrationPolicy.setProviders(resourceManager.providers()); + + resourceGroupName = generateRandomResourceName("rg-storagemover-", 30); + resourceManager.resourceGroups().define(resourceGroupName).withRegion(DEFAULT_REGION).create(); + } + + @Override + protected void cleanUpResources() { + if (resourceGroupName != null) { + try { + resourceManager.resourceGroups().beginDeleteByName(resourceGroupName); + } catch (RuntimeException ignored) { + // Best-effort cleanup; resource-group deletion failures should not + // mask the underlying test failure. + } + } + } + + /** + * Asserts that the given operation throws a {@link ManagementException} + * carrying an HTTP status code in {@code [400, 500)}. Used as the Java + * analogue of .NET's {@code Assert.IsFalse(await coll.ExistsAsync(name))} + * pattern (where the SDK does not surface an {@code Exists} helper). + * + * @param expectedStatus expected HTTP status (typically 404). + * @param action the operation that should throw. + */ + protected static void assertHttpStatus(int expectedStatus, Runnable action) { + ManagementException ex = Assertions.assertThrows(ManagementException.class, action::run); + Assertions.assertEquals(expectedStatus, ex.getResponse().getStatusCode(), "expected HTTP " + expectedStatus + + " but got " + ex.getResponse().getStatusCode() + " — body: " + ex.getValue()); + } + + /** + * Convenience wrapper for the common 404-expected case. + * + * @param action the operation that should produce a 404. + */ + protected static void assertNotFound(Runnable action) { + assertHttpStatus(404, action); + } + + /** + * Returns a {@link ResourceGroup} representing the per-test resource group + * created in {@link #initializeClients}. + * + * @return the per-test resource group. + */ + protected ResourceGroup getResourceGroup() { + return resourceManager.resourceGroups().getByName(resourceGroupName); + } + + private static Region parseRegionOrDefault(String name, Region fallback) { + if (CoreUtils.isNullOrEmpty(name)) { + return fallback; + } + Region parsed = Region.fromName(name); + return parsed != null ? parsed : Region.create(name, name); + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverResourceTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverResourceTests.java new file mode 100644 index 000000000000..58e99af90048 --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverResourceTests.java @@ -0,0 +1,147 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.resourcemanager.storagemover.models.AzureStorageBlobContainerEndpointProperties; +import com.azure.resourcemanager.storagemover.models.Endpoint; +import com.azure.resourcemanager.storagemover.models.EndpointType; +import com.azure.resourcemanager.storagemover.models.Project; +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +/** + * Mirrors {@code StorageMoverResourceTests.cs} from the .NET source-of-truth + * test suite. + */ +public class StorageMoverResourceTests extends StorageMoverManagementTestBase { + + @Test + public void getStorageMover() { + String name = generateRandomResourceName("testsm-get-", 24); + + Map tags = new HashMap<>(); + tags.put("k", "v"); + + StorageMover created = storageMoverManager.storageMovers() + .define(name) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .withTags(tags) + .create(); + + StorageMover fetched1 = storageMoverManager.storageMovers().getByResourceGroup(resourceGroupName, name); + StorageMover fetched2 = storageMoverManager.storageMovers().getByResourceGroup(resourceGroupName, name); + + Assertions.assertEquals(name, fetched1.name()); + Assertions.assertEquals(fetched1.name(), fetched2.name()); + Assertions.assertEquals(fetched1.id(), fetched2.id()); + Assertions.assertEquals(fetched1.location(), fetched2.location()); + Assertions.assertEquals(fetched1.type(), fetched2.type()); + Assertions.assertEquals(fetched1.tags(), fetched2.tags()); + Assertions.assertEquals(created.id(), fetched1.id()); + } + + /** + * Skipped: agents cannot be created by the RP; this scenario requires a real + * registered agent VM — see the cross-language playbook. + */ + @Test + @Disabled("Agents cannot be created by the RP; this test requires a registered agent VM.") + public void getStorageMoverAgent() { + } + + @Test + public void getStorageMoverEndpoint() { + String storageMoverName = generateRandomResourceName("testsm-getep-", 24); + String endpointName = generateRandomResourceName("blobep-", 24); + + storageMoverManager.storageMovers() + .define(storageMoverName) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .create(); + + AzureStorageBlobContainerEndpointProperties props + = new AzureStorageBlobContainerEndpointProperties().withStorageAccountResourceId(FAKE_STORAGE_ACCOUNT_ID) + .withBlobContainerName("testcontainer"); + + storageMoverManager.endpoints() + .define(endpointName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .withProperties(props) + .create(); + + Endpoint fetched = storageMoverManager.endpoints().get(resourceGroupName, storageMoverName, endpointName); + Assertions.assertEquals(endpointName, fetched.name()); + Assertions.assertEquals(EndpointType.AZURE_STORAGE_BLOB_CONTAINER, fetched.properties().endpointType()); + } + + @Test + public void getStorageMoverProject() { + String storageMoverName = generateRandomResourceName("testsm-getproj-", 24); + String projectName = generateRandomResourceName("project-", 24); + + storageMoverManager.storageMovers() + .define(storageMoverName) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .create(); + + storageMoverManager.projects() + .define(projectName) + .withExistingStorageMover(resourceGroupName, storageMoverName) + .create(); + + Project fetched = storageMoverManager.projects().get(resourceGroupName, storageMoverName, projectName); + Assertions.assertEquals(projectName, fetched.name()); + } + + @Test + public void updateAddSetRemoveTagDelete() { + String name = generateRandomResourceName("testsm-tags-", 24); + + // Step 1: create with no tags. + StorageMover sm = storageMoverManager.storageMovers() + .define(name) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .create(); + Assertions.assertEquals(name, sm.name()); + Assertions.assertEquals(DEFAULT_REGION.name(), sm.location()); + + // Step 2: PATCH description (mirrors .NET UpdateAsync(patch{Description = ...})). + sm = sm.refresh().update().withDescription("This is an updated storage mover").apply(); + Assertions.assertEquals("This is an updated storage mover", sm.description()); + + // Step 3: AddTag — replace tag set with {tag1: val1}. Java SDK has no + // dedicated AddTag helper, so use the same fluent update.apply() pattern. + Map tagsAdd = new HashMap<>(); + tagsAdd.put("tag1", "val1"); + sm = sm.update().withTags(tagsAdd).apply(); + Assertions.assertEquals(1, sm.tags().size()); + Assertions.assertEquals("val1", sm.tags().get("tag1")); + + // Step 4: SetTags — replace tag set with {tag2: val2, tag3: val3}. + Map tagsSet = new HashMap<>(); + tagsSet.put("tag2", "val2"); + tagsSet.put("tag3", "val3"); + sm = sm.update().withTags(tagsSet).apply(); + Assertions.assertEquals(2, sm.tags().size()); + + // Step 5: RemoveTag — replace tag set with the remaining {tag3: val3}. + Map tagsAfterRemove = Collections.singletonMap("tag3", "val3"); + sm = sm.update().withTags(tagsAfterRemove).apply(); + Assertions.assertEquals(1, sm.tags().size()); + + // Step 6: Delete and confirm 404 on subsequent get. + storageMoverManager.storageMovers().deleteById(sm.id()); + assertNotFound(() -> storageMoverManager.storageMovers().getByResourceGroup(resourceGroupName, name)); + } +} From 8496bbeadee200321caeaec103c7aa3247d13257 Mon Sep 17 00:00:00 2001 From: Suyash Choudhary Date: Thu, 14 May 2026 11:13:17 +0530 Subject: [PATCH 2/6] Refactor schedule tests to use dynamic start dates and update tag management assertions --- .../storagemover/scenario/EndpointTests.java | 12 +++-- .../scenario/JobDefinitionScheduleTests.java | 18 ++++--- .../StorageMoverManagementTestBase.java | 43 ++++++++++++++--- .../scenario/StorageMoverResourceTests.java | 47 +++++++++++-------- 4 files changed, 84 insertions(+), 36 deletions(-) diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/EndpointTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/EndpointTests.java index 812183d1eca6..3b8a41e13787 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/EndpointTests.java +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/EndpointTests.java @@ -79,7 +79,11 @@ public void createUpdateGetDelete() { Assertions.assertEquals(EndpointType.NFS_MOUNT, nfsEndpoint.properties().endpointType()); NfsMountEndpointProperties nfsProps = (NfsMountEndpointProperties) nfsEndpoint.properties(); Assertions.assertEquals("/", nfsProps.export()); - Assertions.assertEquals("10.0.0.1", nfsProps.host()); + // Note: $..host is rewritten by the framework's default body-key + // sanitizer (TestProxyUtils.JSON_BODY_KEYS_TO_REDACT contains "host"), + // so playback returns the sanitised value rather than the literal IP. + // The serialisation round-trip is covered by NfsMountEndpointPropertiesTests. + Assertions.assertNotNull(nfsProps.host()); // SMB endpoint with credentials. AzureKeyVaultSmbCredentials credentials = new AzureKeyVaultSmbCredentials() @@ -98,7 +102,8 @@ public void createUpdateGetDelete() { smbProps.credentials().usernameUri()); Assertions.assertEquals("https://examples-azureKeyVault.vault.azure.net/secrets/examples-password", smbProps.credentials().passwordUri()); - Assertions.assertEquals("10.0.0.1", smbProps.host()); + // host: see comment on the NFS assertion above (sanitised in playback). + Assertions.assertNotNull(smbProps.host()); Assertions.assertEquals("testshare", smbProps.shareName()); // SMB PATCH — workaround: must include identity:{type:None} at top @@ -119,7 +124,8 @@ public void createUpdateGetDelete() { Assertions.assertEquals(EndpointType.SMB_MOUNT, updatedSmb.properties().endpointType()); Assertions.assertEquals("", updatedSmbProps.credentials().passwordUri()); Assertions.assertEquals("", updatedSmbProps.credentials().usernameUri()); - Assertions.assertEquals("10.0.0.1", updatedSmbProps.host()); + // host: see comment on the NFS assertion above (sanitised in playback). + Assertions.assertNotNull(updatedSmbProps.host()); Assertions.assertEquals("testshare", updatedSmbProps.shareName()); storageMoverManager.endpoints().delete(resourceGroupName, storageMoverName, smbEndpointName); diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java index 16cb23264ae3..4c480c8e65d2 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java @@ -17,6 +17,7 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import java.time.OffsetDateTime; import java.util.Arrays; import java.util.Collections; @@ -24,8 +25,9 @@ * Mirrors {@code JobDefinitionScheduleTests.cs} from the .NET source-of-truth. * *

All schedule {@code startDate}/{@code endDate} values are derived from - * {@link #FIXED_SCHEDULE_START} (a fixed far-future {@code Z}-offset - * {@code OffsetDateTime}) so playback recordings stay deterministic and the + * {@link #scheduleStartDate()} (a {@code Z}-offset {@code OffsetDateTime} of + * {@code now() + 1 day}, sanitized in recordings to a fixed placeholder so + * playback is deterministic) so playback recordings stay portable and the * server does not see the {@code +00:00}-suffix that triggers an RP bug — see * the cross-language playbook. */ @@ -36,11 +38,12 @@ public void createJobDefinitionWithWeeklySchedule() { TestContext ctx = provisionParents(); String jobDefinitionName = generateRandomResourceName("jobdef-sched-", 24); + OffsetDateTime start = scheduleStartDate(); ScheduleInfo schedule = new ScheduleInfo().withFrequency(Frequency.WEEKLY) .withIsActive(true) .withExecutionTime(new SchedulerTime().withHour(2)) - .withStartDate(FIXED_SCHEDULE_START) - .withEndDate(FIXED_SCHEDULE_START.plusDays(30)) + .withStartDate(start) + .withEndDate(start.plusDays(30)) .withDaysOfWeek(Arrays.asList("Monday", "Wednesday", "Friday")); JobDefinition jobDefinition = storageMoverManager.jobDefinitions() @@ -83,11 +86,12 @@ public void createJobDefinitionWithDailyScheduleAndPreservePermissions() { TestContext ctx = provisionParents(); String jobDefinitionName = generateRandomResourceName("jobdef-daily-", 24); + OffsetDateTime start = scheduleStartDate(); ScheduleInfo schedule = new ScheduleInfo().withFrequency(Frequency.DAILY) .withIsActive(true) .withExecutionTime(new SchedulerTime().withHour(0)) - .withStartDate(FIXED_SCHEDULE_START) - .withEndDate(FIXED_SCHEDULE_START.plusDays(30)); + .withStartDate(start) + .withEndDate(start.plusDays(30)); JobDefinition jobDefinition = storageMoverManager.jobDefinitions() .define(jobDefinitionName) @@ -120,7 +124,7 @@ public void createJobDefinitionWithOnetimeSchedule() { ScheduleInfo schedule = new ScheduleInfo().withFrequency(Frequency.ONETIME) .withIsActive(true) .withExecutionTime(new SchedulerTime().withHour(10)) - .withStartDate(FIXED_SCHEDULE_START) + .withStartDate(scheduleStartDate()) .withDaysOfWeek(Collections.emptyList()); JobDefinition jobDefinition = storageMoverManager.jobDefinitions() diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java index 7857d57b385b..12b86cf9f2a0 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java @@ -12,6 +12,8 @@ import com.azure.core.management.Region; import com.azure.core.management.exception.ManagementException; import com.azure.core.management.profile.AzureProfile; +import com.azure.core.test.models.TestProxySanitizer; +import com.azure.core.test.models.TestProxySanitizerType; import com.azure.core.util.Configuration; import com.azure.core.util.CoreUtils; import com.azure.resourcemanager.resources.ResourceManager; @@ -25,8 +27,10 @@ import org.junit.jupiter.api.Assertions; import java.time.OffsetDateTime; +import java.time.ZoneOffset; import java.time.temporal.ChronoUnit; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; /** @@ -47,15 +51,28 @@ public abstract class StorageMoverManagementTestBase extends ResourceManagerTest = parseRegionOrDefault(Configuration.getGlobalConfiguration().get("AZURE_TEST_LOCATION"), Region.US_EAST); /** - * Fixed schedule {@code startDate} used across schedule tests. + * Placeholder value the {@code $..startDate} / {@code $..endDate} body-key + * sanitizers rewrite all schedule dates to. Both the stored recording and + * the live request body during playback get this value, so playback matches + * succeed regardless of when the test is run. + */ + private static final String REDACTED_SCHEDULE_DATE = "2030-01-01T00:00:00Z"; + + /** + * Returns a {@code startDate} suitable for schedule tests. + * + *

The Storage Mover RP rejects any {@code endDate} more than one year + * past wall-clock {@code now()}, so a hard-coded far-future date does not + * work. The body-key sanitizer registered in {@link #beforeTest} rewrites + * the value to {@link #REDACTED_SCHEDULE_DATE} in both the stored recording + * and the live request during playback, keeping the recordings portable. * - *

Java's test-proxy does not have a {@code Recording.Now} equivalent; using - * {@code OffsetDateTime.now()} would produce a different timestamp on every - * run and break playback. The value uses {@code Z} offset suffix (not - * {@code +00:00}) to avoid an RP serialization bug documented in the - * cross-language playbook. + * @return a UTC {@link OffsetDateTime} one day in the future, truncated to + * the day so the JSON payload is stable. */ - protected static final OffsetDateTime FIXED_SCHEDULE_START = OffsetDateTime.parse("2030-01-01T00:00:00Z"); + protected static OffsetDateTime scheduleStartDate() { + return OffsetDateTime.now(ZoneOffset.UTC).plusDays(1).truncatedTo(ChronoUnit.DAYS); + } /** * Well-known resource ids used by the {@code AzureMultiCloudConnector} @@ -106,6 +123,18 @@ protected HttpPipeline buildHttpPipeline(TokenCredential credential, AzureProfil new RetryPolicy("Retry-After", ChronoUnit.SECONDS), mergedPolicies, httpClient); } + @Override + protected void beforeTest() { + // Schedule dates are dynamic ("now + N days") so the RP accepts them, + // but we sanitize them to a fixed placeholder so recordings replay on + // any date. The sanitizer is bidirectional: applied both when storing + // recordings and when matching incoming requests during playback. + interceptorManager.addSanitizers(Arrays.asList( + new TestProxySanitizer("$..startDate", null, REDACTED_SCHEDULE_DATE, TestProxySanitizerType.BODY_KEY), + new TestProxySanitizer("$..endDate", null, REDACTED_SCHEDULE_DATE, TestProxySanitizerType.BODY_KEY))); + super.beforeTest(); + } + @Override protected void initializeClients(HttpPipeline httpPipeline, AzureProfile profile) { ResourceManagerUtils.InternalRuntimeContext.setDelayProvider(new TestDelayProvider(!isPlaybackMode())); diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverResourceTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverResourceTests.java index 58e99af90048..efaad1c1b93e 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverResourceTests.java +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverResourceTests.java @@ -107,7 +107,11 @@ public void getStorageMoverProject() { public void updateAddSetRemoveTagDelete() { String name = generateRandomResourceName("testsm-tags-", 24); - // Step 1: create with no tags. + // Step 1: create with no explicit tags. (Note: some subscriptions apply + // default tags via Azure Policy, so the resource may already have one + // or more system-managed tags at this point. Tests should not assume a + // specific tag-set size; they only assert that the tags WE manage are + // present or absent as expected.) StorageMover sm = storageMoverManager.storageMovers() .define(name) .withRegion(DEFAULT_REGION) @@ -116,29 +120,34 @@ public void updateAddSetRemoveTagDelete() { Assertions.assertEquals(name, sm.name()); Assertions.assertEquals(DEFAULT_REGION.name(), sm.location()); - // Step 2: PATCH description (mirrors .NET UpdateAsync(patch{Description = ...})). + // Step 2: PATCH description. sm = sm.refresh().update().withDescription("This is an updated storage mover").apply(); Assertions.assertEquals("This is an updated storage mover", sm.description()); - // Step 3: AddTag — replace tag set with {tag1: val1}. Java SDK has no - // dedicated AddTag helper, so use the same fluent update.apply() pattern. - Map tagsAdd = new HashMap<>(); - tagsAdd.put("tag1", "val1"); - sm = sm.update().withTags(tagsAdd).apply(); - Assertions.assertEquals(1, sm.tags().size()); + // Step 3: PATCH-set tag1. The Storage Mover RP's PATCH on the tags + // field REPLACES user-supplied tags (matching .NET's SetTagsAsync + // semantic), so any previously-set user tags are dropped. System or + // policy-applied tags, if any, are preserved by the RP across writes. + sm = sm.update().withTags(Collections.singletonMap("tag1", "val1")).apply(); Assertions.assertEquals("val1", sm.tags().get("tag1")); - // Step 4: SetTags — replace tag set with {tag2: val2, tag3: val3}. - Map tagsSet = new HashMap<>(); - tagsSet.put("tag2", "val2"); - tagsSet.put("tag3", "val3"); - sm = sm.update().withTags(tagsSet).apply(); - Assertions.assertEquals(2, sm.tags().size()); - - // Step 5: RemoveTag — replace tag set with the remaining {tag3: val3}. - Map tagsAfterRemove = Collections.singletonMap("tag3", "val3"); - sm = sm.update().withTags(tagsAfterRemove).apply(); - Assertions.assertEquals(1, sm.tags().size()); + // Step 4: PATCH-set tag2 — REPLACES tag1 with tag2 (user tags only; + // policy tags persist). + sm = sm.update().withTags(Collections.singletonMap("tag2", "val2")).apply(); + Assertions.assertEquals("val2", sm.tags().get("tag2")); + Assertions.assertFalse(sm.tags().containsKey("tag1"), "PATCH should replace user tag1 with tag2"); + + // Step 5: PUT-replace via idempotent define. End state: only tag3 of + // user-supplied tags is present. + sm = storageMoverManager.storageMovers() + .define(name) + .withRegion(DEFAULT_REGION) + .withExistingResourceGroup(resourceGroupName) + .withTags(Collections.singletonMap("tag3", "val3")) + .create(); + Assertions.assertEquals("val3", sm.tags().get("tag3")); + Assertions.assertFalse(sm.tags().containsKey("tag1"), "PUT should not retain previously-PATCHed tag1"); + Assertions.assertFalse(sm.tags().containsKey("tag2"), "PUT should not retain previously-PATCHed tag2"); // Step 6: Delete and confirm 404 on subsequent get. storageMoverManager.storageMovers().deleteById(sm.id()); From 7dc6f8702cff2281a64775a1717a406d1d1ef2a9 Mon Sep 17 00:00:00 2001 From: Suyash Choudhary Date: Thu, 14 May 2026 11:17:50 +0530 Subject: [PATCH 3/6] Update Tag in assets.json for storagemover to reflect current version --- sdk/storagemover/azure-resourcemanager-storagemover/assets.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/assets.json b/sdk/storagemover/azure-resourcemanager-storagemover/assets.json index cde93b8b81c4..a21ca75d7002 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/assets.json +++ b/sdk/storagemover/azure-resourcemanager-storagemover/assets.json @@ -2,5 +2,5 @@ "AssetsRepo": "Azure/azure-sdk-assets", "AssetsRepoPrefixPath": "java", "TagPrefix": "java/storagemover/azure-resourcemanager-storagemover", - "Tag": "" + "Tag": "java/storagemover/azure-resourcemanager-storagemover_e6e92d3940" } From 92f50ad671b491c916fcb5aa97659b38ef275442 Mon Sep 17 00:00:00 2001 From: Suyash Choudhary Date: Wed, 27 May 2026 15:05:00 +0530 Subject: [PATCH 4/6] Update assets.json tag and add scenario tests for Connection and JobDefinition with private source --- .../assets.json | 2 +- .../pom.xml | 18 ++ .../scenario/ConnectionTests.java | 98 ++++++ .../JobDefinitionPrivateSourceTests.java | 240 +++++++++++++++ .../StorageMoverManagementTestBase.java | 286 +++++++++++++++++- 5 files changed, 637 insertions(+), 7 deletions(-) create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ConnectionTests.java create mode 100644 sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionPrivateSourceTests.java diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/assets.json b/sdk/storagemover/azure-resourcemanager-storagemover/assets.json index a21ca75d7002..12453dfabf4b 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/assets.json +++ b/sdk/storagemover/azure-resourcemanager-storagemover/assets.json @@ -2,5 +2,5 @@ "AssetsRepo": "Azure/azure-sdk-assets", "AssetsRepoPrefixPath": "java", "TagPrefix": "java/storagemover/azure-resourcemanager-storagemover", - "Tag": "java/storagemover/azure-resourcemanager-storagemover_e6e92d3940" + "Tag": "java/storagemover/azure-resourcemanager-storagemover_f2516d6925" } diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/pom.xml b/sdk/storagemover/azure-resourcemanager-storagemover/pom.xml index 000df1a0bec6..e992718da85e 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/pom.xml +++ b/sdk/storagemover/azure-resourcemanager-storagemover/pom.xml @@ -75,6 +75,24 @@ 2.54.1 test + + com.azure.resourcemanager + azure-resourcemanager-network + 2.58.2 + test + + + com.azure.resourcemanager + azure-resourcemanager-authorization + 2.53.9 + test + + + com.azure.resourcemanager + azure-resourcemanager-storage + 2.56.0 + test + com.azure.resourcemanager azure-resourcemanager-test diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ConnectionTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ConnectionTests.java new file mode 100644 index 000000000000..10c7d2d19af0 --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ConnectionTests.java @@ -0,0 +1,98 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.core.management.Region; +import com.azure.resourcemanager.storagemover.models.Connection; +import com.azure.resourcemanager.storagemover.models.ConnectionProperties; +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.stream.StreamSupport; + +/** + * Mirrors {@code ConnectionTests.cs} from the .NET source-of-truth (row #32 of + * the cross-language matrix). Exercises Connection CRUD against the shared + * private-link service {@code test-pls-wcs}. + * + *

Operates in {@code westcentralus} because the upstream PLS is deployed + * there; the per-test resource group is provisioned in the same region so + * private endpoint provisioning stays in-region. + * + *

This test intentionally does not assert on {@code connectionStatus} — + * PLS provisioning is asynchronous and the status starts as {@code Pending}. + * The status assertion lives in the C2C-with-private-source scenario (row + * #31) where the PE is explicitly approved. + * + *

The {@code description} field on update is also intentionally not asserted + * to equal the new value — the RP echoes the stale (create-time) description + * for several seconds after a PATCH and the assertion would be flaky across + * languages (Python and JS hit the same behaviour). + */ +public class ConnectionTests extends StorageMoverManagementTestBase { + + @Override + protected Region testRegion() { + return WEST_CENTRAL_US; + } + + @Test + public void createGetListUpdateDelete() { + String storageMoverName = generateRandomResourceName("stomover-conn-", 24); + String connectionName = generateRandomResourceName("conn-", 24); + + StorageMover sm = storageMoverManager.storageMovers() + .define(storageMoverName) + .withRegion(testRegion()) + .withExistingResourceGroup(resourceGroupName) + .create(); + + try { + Connection created = storageMoverManager.connections() + .define(connectionName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties(new ConnectionProperties().withDescription("initial description") + .withPrivateLinkServiceId(PRIVATE_LINK_SERVICE_ID)) + .create(); + Assertions.assertEquals(connectionName, created.name()); + Assertions.assertNotNull(created.properties()); + Assertions.assertEquals("initial description", created.properties().description()); + Assertions.assertEquals(PRIVATE_LINK_SERVICE_ID, created.properties().privateLinkServiceId()); + + Connection fetched = storageMoverManager.connections().get(resourceGroupName, sm.name(), connectionName); + Assertions.assertEquals(connectionName, fetched.name()); + Assertions.assertEquals(PRIVATE_LINK_SERVICE_ID, fetched.properties().privateLinkServiceId()); + + long count = StreamSupport + .stream(storageMoverManager.connections().list(resourceGroupName, sm.name()).spliterator(), false) + .count(); + Assertions.assertTrue(count >= 1, "expected at least one connection but found " + count); + + // Update keeps the same PLS id (cannot be changed post-create) and + // changes only the description. The new description is intentionally + // NOT asserted because the RP echoes the create-time value for several + // seconds after the PATCH (cross-language flakiness — see playbook). + Connection updated = fetched.update() + .withProperties(new ConnectionProperties().withDescription("updated description") + .withPrivateLinkServiceId(PRIVATE_LINK_SERVICE_ID)) + .apply(); + Assertions.assertEquals(connectionName, updated.name()); + + Connection refreshed = updated.refresh(); + Assertions.assertEquals(connectionName, refreshed.name()); + + storageMoverManager.connections().delete(resourceGroupName, sm.name(), connectionName); + assertNotFound(() -> storageMoverManager.connections().get(resourceGroupName, sm.name(), connectionName)); + } finally { + // Best-effort cleanup in case the test failed before the explicit + // delete above. Idempotent — delete on a missing resource is a 204. + try { + storageMoverManager.connections().delete(resourceGroupName, sm.name(), connectionName); + } catch (RuntimeException ignored) { + // already deleted or never created. + } + } + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionPrivateSourceTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionPrivateSourceTests.java new file mode 100644 index 000000000000..39d3f56a50cc --- /dev/null +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionPrivateSourceTests.java @@ -0,0 +1,240 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +package com.azure.resourcemanager.storagemover.scenario; + +import com.azure.core.management.Region; +import com.azure.resourcemanager.network.fluent.models.PrivateEndpointConnectionInner; +import com.azure.resourcemanager.storage.models.BlobContainer; +import com.azure.resourcemanager.storage.models.PublicAccess; +import com.azure.resourcemanager.storagemover.models.AzureMultiCloudConnectorEndpointProperties; +import com.azure.resourcemanager.storagemover.models.AzureStorageBlobContainerEndpointProperties; +import com.azure.resourcemanager.storagemover.models.Connection; +import com.azure.resourcemanager.storagemover.models.ConnectionProperties; +import com.azure.resourcemanager.storagemover.models.CopyMode; +import com.azure.resourcemanager.storagemover.models.DataIntegrityValidation; +import com.azure.resourcemanager.storagemover.models.Endpoint; +import com.azure.resourcemanager.storagemover.models.EndpointKind; +import com.azure.resourcemanager.storagemover.models.JobDefinition; +import com.azure.resourcemanager.storagemover.models.JobRun; +import com.azure.resourcemanager.storagemover.models.JobRunResourceId; +import com.azure.resourcemanager.storagemover.models.JobRunStatus; +import com.azure.resourcemanager.storagemover.models.JobType; +import com.azure.resourcemanager.storagemover.models.ManagedServiceIdentity; +import com.azure.resourcemanager.storagemover.models.ManagedServiceIdentityType; +import com.azure.resourcemanager.storagemover.models.Project; +import com.azure.resourcemanager.storagemover.models.StorageMover; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.time.Duration; +import java.util.Collections; +import java.util.HashSet; +import java.util.Locale; +import java.util.Set; + +/** + * Mirrors the {@code StartC2CJobWithPrivateSourceTest} scenario (row #31 of + * the cross-language matrix). Drives the full 12-step private-source + * Cloud-to-Cloud flow end-to-end: + * + *

    + *
  1. Self-provision storage mover + project in {@code westcentralus} (the + * per-test resource group is already in that region via + * {@link #testRegion()}).
    2. + *
  2. Create a per-test target blob container under + * {@link #TEST_STORAGE_ACCOUNT_NAME} so parallel runs do not race over + * the same container.
    3. + *
  3. Create the Storage Mover {@link Connection} referencing + * {@link #PRIVATE_LINK_SERVICE_ID}; capture the auto-created PE id.
    4. + *
  4. Locate the matching PE-connection on the PLS (poll up to 150s).
    5. + *
  5. PATCH the PE-connection {@code Approved}.
    6. + *
  6. Poll the Storage Mover Connection until {@code connectionStatus = + * Approved} (the RP propagates the PLS-side approval asynchronously — + * up to 5 min).
    7. + *
  7. Create the target Blob endpoint with explicit + * {@link ManagedServiceIdentityType#SYSTEM_ASSIGNED}; capture + * {@code identity.principalId}.
    8. + *
  8. Assign {@code Storage Blob Data Contributor} to the MSI on the + * container scope (retry on {@code PrincipalNotFound}).
    9. + *
  9. Create the source MCC endpoint over + * {@link #AWS_PRIVATE_S3_BUCKET_ID}.
    10. + *
  10. Create the C2C {@link JobDefinition} + * (copyMode={@link CopyMode#ADDITIVE}, agentless, with the connection in + * {@code connections}).
    11. + *
  11. {@code startJob} → poll the resulting {@link JobRun} on a 30s cadence + * for up to 30 minutes; expect terminal {@link JobRunStatus#SUCCEEDED} + * in 3-5 minutes.
    12. + *
  12. Tear down (role assignment → connection → container) with a 60s + * grace period between connection delete and container delete so the + * PLS releases the slot before the next test claims it.
    13. + *
+ * + *

Lives in its own class (separate from {@link JobDefinitionJobRunTests}) so + * the per-test resource group can be pinned to {@code westcentralus} via + * {@link #testRegion()}; the other job-definition test runs in + * {@link #DEFAULT_REGION}. + */ +public class JobDefinitionPrivateSourceTests extends StorageMoverManagementTestBase { + + /** Job-run terminal states (the polling loop exits on any of these). */ + private static final Set TERMINAL_STATES = Collections.unmodifiableSet( + new HashSet<>(java.util.Arrays.asList(JobRunStatus.SUCCEEDED, JobRunStatus.FAILED, JobRunStatus.CANCELED))); + + @Override + protected Region testRegion() { + return WEST_CENTRAL_US; + } + + @Test + public void startC2CJobWithPrivateSource() { + String storageMoverName = generateRandomResourceName("stomover-c2cps-", 24); + String projectName = generateRandomResourceName("project-c2cps-", 24); + String connectionName = generateRandomResourceName("conn-c2cps-", 24); + String sourceEndpointName = generateRandomResourceName("mccep-", 24); + String targetEndpointName = generateRandomResourceName("blobep-", 24); + String jobDefinitionName = generateRandomResourceName("jobdef-c2cps-", 24); + // Container name must be lowercase per Azure Storage naming rules. + String containerName = generateRandomResourceName("tc", 24).toLowerCase(Locale.ROOT); + + String roleAssignmentName = null; + boolean containerCreated = false; + + StorageMover sm = storageMoverManager.storageMovers() + .define(storageMoverName) + .withRegion(testRegion()) + .withExistingResourceGroup(resourceGroupName) + .create(); + + Project project = storageMoverManager.projects() + .define(projectName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .create(); + Assertions.assertNotNull(project); + + try { + // Step 2: per-test target container in cpmoveraccount. + BlobContainer container = storageManager(XDATAMOVE_SYNTHETICS_SUB_ID).blobContainers() + .defineContainer(containerName) + .withExistingBlobService(TEST_STORAGE_ACCOUNT_RG, TEST_STORAGE_ACCOUNT_NAME) + .withPublicAccess(PublicAccess.NONE) + .create(); + containerCreated = true; + String containerScope = container.id(); + + // Step 3: create the Storage Mover Connection bound to the PLS. + Connection connection = storageMoverManager.connections() + .define(connectionName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties(new ConnectionProperties().withDescription("C2C private source") + .withPrivateLinkServiceId(PRIVATE_LINK_SERVICE_ID)) + .create(); + Assertions.assertNotNull(connection.properties()); + String privateEndpointResourceId = connection.properties().privateEndpointResourceId(); + Assertions.assertNotNull(privateEndpointResourceId, + "Storage Mover RP did not return privateEndpointResourceId on the Connection create response"); + + // Steps 4-5: locate the PE on the PLS and approve it. + PrivateEndpointConnectionInner peConnection = findPrivateEndpointConnection(privateEndpointResourceId); + approvePrivateEndpointConnection(peConnection.name()); + + // Step 6: wait for the Storage Mover Connection to flip Approved. + waitForConnectionApproved(sm.name(), connectionName); + + // Step 7: target Blob endpoint with explicit SystemAssigned MSI. + Endpoint blobEndpoint = storageMoverManager.endpoints() + .define(targetEndpointName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties(new AzureStorageBlobContainerEndpointProperties() + .withStorageAccountResourceId(TEST_STORAGE_ACCOUNT_ID) + .withBlobContainerName(containerName)) + .withIdentity(new ManagedServiceIdentity().withType(ManagedServiceIdentityType.SYSTEM_ASSIGNED)) + .create(); + Assertions.assertNotNull(blobEndpoint.identity(), "blob endpoint create did not return an identity block"); + String principalId = blobEndpoint.identity().principalId(); + Assertions.assertNotNull(principalId, "blob endpoint identity.principalId was null"); + + // Step 8: RBAC assignment with PrincipalNotFound retry. + roleAssignmentName = assignBlobDataContributorWithRetry(principalId, containerScope); + + // Step 9: source MCC endpoint over the private bucket. + Endpoint mccEndpoint + = storageMoverManager.endpoints() + .define(sourceEndpointName) + .withExistingStorageMover(resourceGroupName, sm.name()) + .withProperties(new AzureMultiCloudConnectorEndpointProperties() + .withMultiCloudConnectorId(MULTI_CLOUD_CONNECTOR_ID) + .withAwsS3BucketId(AWS_PRIVATE_S3_BUCKET_ID) + .withEndpointKind(EndpointKind.SOURCE)) + .create(); + + // Step 10: C2C JobDefinition (agentless, with the connection). + JobDefinition jobDefinition = storageMoverManager.jobDefinitions() + .define(jobDefinitionName) + .withExistingProject(resourceGroupName, sm.name(), project.name()) + .withCopyMode(CopyMode.ADDITIVE) + .withSourceName(mccEndpoint.name()) + .withTargetName(blobEndpoint.name()) + .withDescription("C2C with private source") + .withJobType(JobType.CLOUD_TO_CLOUD) + .withSourceSubpath("/") + .withTargetSubpath("/") + .withConnections(Collections.singletonList(connection.id())) + .withDataIntegrityValidation(DataIntegrityValidation.NONE) + .create(); + Assertions.assertEquals(jobDefinitionName, jobDefinition.name()); + Assertions.assertEquals(CopyMode.ADDITIVE, jobDefinition.copyMode()); + + // Step 11: startJob → poll up to 30 min on a 30s cadence. + JobRunResourceId startResult = jobDefinition.startJob(); + Assertions.assertNotNull(startResult); + String jobRunFullId = startResult.jobRunResourceId(); + Assertions.assertNotNull(jobRunFullId, "startJob returned a null jobRunResourceId"); + String jobRunName = jobRunFullId.substring(jobRunFullId.lastIndexOf('/') + 1); + + JobRunStatus finalStatus = null; + for (int attempt = 0; attempt < 60; attempt++) { + JobRun run = storageMoverManager.jobRuns() + .get(resourceGroupName, sm.name(), project.name(), jobDefinitionName, jobRunName); + JobRunStatus status = run.status(); + if (status != null && TERMINAL_STATES.contains(status)) { + finalStatus = status; + break; + } + sleep(Duration.ofSeconds(30)); + } + Assertions.assertEquals(JobRunStatus.SUCCEEDED, finalStatus, + "expected job run to finish Succeeded but got " + finalStatus); + } finally { + // Step 12: ordered cleanup. Each step is best-effort so an earlier + // failure does not mask the underlying test error. + if (roleAssignmentName != null) { + try { + authorizationManager(XDATAMOVE_SYNTHETICS_SUB_ID).roleAssignments() + .deleteById("/subscriptions/" + XDATAMOVE_SYNTHETICS_SUB_ID + "/resourceGroups/" + + TEST_STORAGE_ACCOUNT_RG + "/providers/Microsoft.Storage/storageAccounts/" + + TEST_STORAGE_ACCOUNT_NAME + "/blobServices/default/containers/" + containerName + + "/providers/Microsoft.Authorization/roleAssignments/" + roleAssignmentName); + } catch (RuntimeException ignored) { + // best effort + } + } + try { + storageMoverManager.connections().delete(resourceGroupName, sm.name(), connectionName); + } catch (RuntimeException ignored) { + // best effort — RG deletion in cleanUpResources will pick up stragglers + } + // Give the PLS time to release the slot before the next test claims + // it. .NET hit NoValidConnectionFound on back-to-back runs without this. + sleep(Duration.ofSeconds(60)); + if (containerCreated) { + try { + storageManager(XDATAMOVE_SYNTHETICS_SUB_ID).blobContainers() + .delete(TEST_STORAGE_ACCOUNT_RG, TEST_STORAGE_ACCOUNT_NAME, containerName); + } catch (RuntimeException ignored) { + // best effort + } + } + } + } +} diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java index 12b86cf9f2a0..79297c32b3cd 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java @@ -9,6 +9,7 @@ import com.azure.core.http.policy.HttpLogOptions; import com.azure.core.http.policy.HttpPipelinePolicy; import com.azure.core.http.policy.RetryPolicy; +import com.azure.core.management.AzureEnvironment; import com.azure.core.management.Region; import com.azure.core.management.exception.ManagementException; import com.azure.core.management.profile.AzureProfile; @@ -16,22 +17,32 @@ import com.azure.core.test.models.TestProxySanitizerType; import com.azure.core.util.Configuration; import com.azure.core.util.CoreUtils; +import com.azure.resourcemanager.authorization.AuthorizationManager; +import com.azure.resourcemanager.authorization.models.BuiltInRole; +import com.azure.resourcemanager.network.NetworkManager; +import com.azure.resourcemanager.network.fluent.models.PrivateEndpointConnectionInner; +import com.azure.resourcemanager.network.models.PrivateLinkServiceConnectionState; import com.azure.resourcemanager.resources.ResourceManager; import com.azure.resourcemanager.resources.fluentcore.policy.ProviderRegistrationPolicy; import com.azure.resourcemanager.resources.fluentcore.utils.HttpPipelineProvider; import com.azure.resourcemanager.resources.fluentcore.utils.ResourceManagerUtils; import com.azure.resourcemanager.resources.models.ResourceGroup; +import com.azure.resourcemanager.storage.StorageManager; import com.azure.resourcemanager.storagemover.StorageMoverManager; +import com.azure.resourcemanager.storagemover.models.Connection; +import com.azure.resourcemanager.storagemover.models.ConnectionStatus; import com.azure.resourcemanager.test.ResourceManagerTestProxyTestBase; import com.azure.resourcemanager.test.utils.TestDelayProvider; import org.junit.jupiter.api.Assertions; +import java.time.Duration; import java.time.OffsetDateTime; import java.time.ZoneOffset; import java.time.temporal.ChronoUnit; import java.util.ArrayList; import java.util.Arrays; import java.util.List; +import java.util.Objects; /** * Base class for Storage Mover scenario tests. @@ -50,6 +61,15 @@ public abstract class StorageMoverManagementTestBase extends ResourceManagerTest protected static final Region DEFAULT_REGION = parseRegionOrDefault(Configuration.getGlobalConfiguration().get("AZURE_TEST_LOCATION"), Region.US_EAST); + /** + * Region where the cross-sub private-link / cpmoveraccount / AWS private + * bucket fixtures live. The Storage Mover {@code cpmoveraccount} and the + * {@code test-pls-wcs} PrivateLinkService are deployed in {@code + * westcentralus}. Private-link tests therefore self-provision their + * resource group in that region so PE traffic stays in-region. + */ + protected static final Region WEST_CENTRAL_US = Region.US_WEST_CENTRAL; + /** * Placeholder value the {@code $..startDate} / {@code $..endDate} body-key * sanitizers rewrite all schedule dates to. Both the stored recording and @@ -74,18 +94,58 @@ protected static OffsetDateTime scheduleStartDate() { return OffsetDateTime.now(ZoneOffset.UTC).plusDays(1).truncatedTo(ChronoUnit.DAYS); } + /** + * Cross-language shared fixture subscription + * ({@code XDataMove-Synthetics}). Hosts the private-link service, the + * private AWS S3 bucket, and the {@code cpmoveraccount} storage account + * used by the C2C-with-private-source scenario. + */ + protected static final String XDATAMOVE_SYNTHETICS_SUB_ID = "b6b34ad8-ca89-4f85-beb7-c2ec13702dac"; + /** * Well-known resource ids used by the {@code AzureMultiCloudConnector} * endpoint scenarios. Mirrors the constants in * {@code StorageMoverManagementTestBase.cs} from .NET. */ protected static final String MULTI_CLOUD_CONNECTOR_ID - = "/subscriptions/b6b34ad8-ca89-4f85-beb7-c2ec13702dac/resourceGroups/E2E-Management-RGsyn" + = "/subscriptions/" + XDATAMOVE_SYNTHETICS_SUB_ID + "/resourceGroups/E2E-Management-RGsyn" + "/providers/Microsoft.HybridConnectivity/publicCloudConnectors/e2e-sm-rp-connector"; - protected static final String AWS_S3_BUCKET_ID - = "/subscriptions/b6b34ad8-ca89-4f85-beb7-c2ec13702dac/resourceGroups/aws_640698235822" - + "/providers/Microsoft.AWSConnector/s3Buckets/e2e-sm-rp-bucket"; + protected static final String AWS_S3_BUCKET_ID = "/subscriptions/" + XDATAMOVE_SYNTHETICS_SUB_ID + + "/resourceGroups/aws_640698235822/providers/Microsoft.AWSConnector/s3Buckets/e2e-sm-rp-bucket"; + + /** + * AWS S3 bucket reachable only over the private endpoint (rows #31/#32 of + * the cross-language matrix). + */ + protected static final String AWS_PRIVATE_S3_BUCKET_ID = "/subscriptions/" + XDATAMOVE_SYNTHETICS_SUB_ID + + "/resourceGroups/aws_640698235822/providers/Microsoft.AWSConnector/s3Buckets/e2e-sm-rp-private-bucket"; + + /** + * PrivateLinkService that fronts the AWS private bucket. The Connection + * resource references this id; PE-approval helpers live in this base. + */ + protected static final String PRIVATE_LINK_SERVICE_RG = "E2E-Management-RGsyn"; + protected static final String PRIVATE_LINK_SERVICE_NAME = "test-pls-wcs"; + protected static final String PRIVATE_LINK_SERVICE_ID + = "/subscriptions/" + XDATAMOVE_SYNTHETICS_SUB_ID + "/resourceGroups/" + PRIVATE_LINK_SERVICE_RG + + "/providers/Microsoft.Network/privateLinkServices/" + PRIVATE_LINK_SERVICE_NAME; + + /** + * Storage account holding the per-test target blob containers used by the + * C2C-with-private-source scenario. + */ + protected static final String TEST_STORAGE_ACCOUNT_RG = "CP_Mover_IN_WCUS"; + protected static final String TEST_STORAGE_ACCOUNT_NAME = "cpmoveraccount"; + protected static final String TEST_STORAGE_ACCOUNT_ID + = "/subscriptions/" + XDATAMOVE_SYNTHETICS_SUB_ID + "/resourceGroups/" + TEST_STORAGE_ACCOUNT_RG + + "/providers/Microsoft.Storage/storageAccounts/" + TEST_STORAGE_ACCOUNT_NAME; + + /** + * Built-in {@code Storage Blob Data Contributor} role definition GUID + * (subscription-scope role-definition id is composed by the helper). + */ + protected static final String STORAGE_BLOB_DATA_CONTRIBUTOR_ROLE_ID = "ba92f5b4-2d11-453d-a403-e96b0029c9fe"; /** * Placeholder storage account resource id used when an endpoint requires a @@ -101,6 +161,19 @@ protected static OffsetDateTime scheduleStartDate() { protected ResourceManager resourceManager; protected String resourceGroupName; + /** + * The HTTP pipeline shared across all managers in a test run (set by + * {@link #initializeClients}). Cross-subscription managers reuse this + * pipeline so requests flow through the same recorder / playback proxy. + */ + private HttpPipeline sharedHttpPipeline; + private AzureProfile sharedTestProfile; + + /** Cached cross-sub managers (one of each is sufficient for the suite). */ + private NetworkManager xDataMoveNetworkManager; + private AuthorizationManager xDataMoveAuthorizationManager; + private StorageManager xDataMoveStorageManager; + /** * Provider registration policy. Has to be a member field because the * pipeline (and therefore the policy) must exist before the @@ -109,6 +182,17 @@ protected static OffsetDateTime scheduleStartDate() { */ private final ProviderRegistrationPolicy providerRegistrationPolicy = new ProviderRegistrationPolicy(); + /** + * Region the per-test resource group is created in. Subclasses override to + * pin themselves to a non-default region (e.g. private-link scenarios that + * must run in {@code westcentralus}). + * + * @return the region for the per-test resource group. + */ + protected Region testRegion() { + return DEFAULT_REGION; + } + @Override protected HttpPipeline buildHttpPipeline(TokenCredential credential, AzureProfile profile, HttpLogOptions httpLogOptions, List policies, HttpClient httpClient) { @@ -129,9 +213,16 @@ protected void beforeTest() { // but we sanitize them to a fixed placeholder so recordings replay on // any date. The sanitizer is bidirectional: applied both when storing // recordings and when matching incoming requests during playback. + // Cross-sub principalIds and PE names are server-generated per-run and + // must be redacted in body too — URL sub-id sanitization is already + // handled by the framework's default sanitizers. interceptorManager.addSanitizers(Arrays.asList( new TestProxySanitizer("$..startDate", null, REDACTED_SCHEDULE_DATE, TestProxySanitizerType.BODY_KEY), - new TestProxySanitizer("$..endDate", null, REDACTED_SCHEDULE_DATE, TestProxySanitizerType.BODY_KEY))); + new TestProxySanitizer("$..endDate", null, REDACTED_SCHEDULE_DATE, TestProxySanitizerType.BODY_KEY), + new TestProxySanitizer("$..principalId", null, "00000000-0000-0000-0000-000000000000", + TestProxySanitizerType.BODY_KEY), + new TestProxySanitizer("$..tenantId", null, "00000000-0000-0000-0000-000000000000", + TestProxySanitizerType.BODY_KEY))); super.beforeTest(); } @@ -139,6 +230,9 @@ protected void beforeTest() { protected void initializeClients(HttpPipeline httpPipeline, AzureProfile profile) { ResourceManagerUtils.InternalRuntimeContext.setDelayProvider(new TestDelayProvider(!isPlaybackMode())); + this.sharedHttpPipeline = httpPipeline; + this.sharedTestProfile = profile; + // StorageMoverManager has no public 2-arg constructor, so the generic // buildManager() helper from the base does not work — use the static // authenticate factory instead. @@ -150,7 +244,7 @@ protected void initializeClients(HttpPipeline httpPipeline, AzureProfile profile providerRegistrationPolicy.setProviders(resourceManager.providers()); resourceGroupName = generateRandomResourceName("rg-storagemover-", 30); - resourceManager.resourceGroups().define(resourceGroupName).withRegion(DEFAULT_REGION).create(); + resourceManager.resourceGroups().define(resourceGroupName).withRegion(testRegion()).create(); } @Override @@ -199,6 +293,186 @@ protected ResourceGroup getResourceGroup() { return resourceManager.resourceGroups().getByName(resourceGroupName); } + /** + * Sleeps for the given duration in live / record mode but skips the sleep + * during playback (the recording captures the post-wait state). Wraps + * {@link ResourceManagerUtils#sleep(Duration)} for clarity at call sites. + * + * @param duration how long to sleep in live mode. + */ + protected void sleep(Duration duration) { + ResourceManagerUtils.sleep(duration); + } + + /** + * Lazily authenticates a {@link NetworkManager} bound to the supplied + * subscription, reusing the shared HTTP pipeline so cross-sub calls are + * captured by the test recorder. + * + * @param subscriptionId target subscription id. + * @return a cached {@link NetworkManager} for the subscription. + */ + protected NetworkManager networkManager(String subscriptionId) { + if (xDataMoveNetworkManager == null) { + xDataMoveNetworkManager = NetworkManager.authenticate(sharedHttpPipeline, profileFor(subscriptionId)); + } + return xDataMoveNetworkManager; + } + + /** + * Lazily authenticates an {@link AuthorizationManager} bound to the + * supplied subscription, reusing the shared HTTP pipeline. + * + * @param subscriptionId target subscription id. + * @return a cached {@link AuthorizationManager} for the subscription. + */ + protected AuthorizationManager authorizationManager(String subscriptionId) { + if (xDataMoveAuthorizationManager == null) { + xDataMoveAuthorizationManager + = AuthorizationManager.authenticate(sharedHttpPipeline, profileFor(subscriptionId)); + } + return xDataMoveAuthorizationManager; + } + + /** + * Lazily authenticates a {@link StorageManager} bound to the supplied + * subscription, reusing the shared HTTP pipeline. + * + * @param subscriptionId target subscription id. + * @return a cached {@link StorageManager} for the subscription. + */ + protected StorageManager storageManager(String subscriptionId) { + if (xDataMoveStorageManager == null) { + xDataMoveStorageManager = StorageManager.authenticate(sharedHttpPipeline, profileFor(subscriptionId)); + } + return xDataMoveStorageManager; + } + + private AzureProfile profileFor(String subscriptionId) { + AzureEnvironment env = sharedTestProfile != null ? sharedTestProfile.getEnvironment() : AzureEnvironment.AZURE; + String tenantId = sharedTestProfile != null ? sharedTestProfile.getTenantId() : null; + return new AzureProfile(tenantId, subscriptionId, env); + } + + /** + * Locates the PE-connection on the PLS whose backing private endpoint + * matches the supplied id. The Storage Mover RP provisions the PE + * asynchronously, so the lookup polls up to {@code 10 * 15s = 150s} before + * giving up. + * + * @param privateEndpointResourceId fully-qualified private endpoint ARM id + * captured from {@link Connection#properties()}. + * @return the matching {@link PrivateEndpointConnectionInner}. + * @throws IllegalStateException if no matching connection appears within + * the polling window. + */ + protected PrivateEndpointConnectionInner findPrivateEndpointConnection(String privateEndpointResourceId) { + Objects.requireNonNull(privateEndpointResourceId, "privateEndpointResourceId"); + String targetName = lastSegment(privateEndpointResourceId); + for (int attempt = 0; attempt < 10; attempt++) { + for (PrivateEndpointConnectionInner conn : networkManager(XDATAMOVE_SYNTHETICS_SUB_ID).serviceClient() + .getPrivateLinkServices() + .listPrivateEndpointConnections(PRIVATE_LINK_SERVICE_RG, PRIVATE_LINK_SERVICE_NAME)) { + if (conn.privateEndpoint() != null + && targetName.equalsIgnoreCase(lastSegment(conn.privateEndpoint().id()))) { + return conn; + } + } + sleep(Duration.ofSeconds(15)); + } + throw new IllegalStateException( + "no PrivateEndpointConnection on " + PRIVATE_LINK_SERVICE_NAME + " matched " + privateEndpointResourceId); + } + + private static String lastSegment(String resourceId) { + if (resourceId == null) { + return null; + } + int idx = resourceId.lastIndexOf('/'); + return idx < 0 ? resourceId : resourceId.substring(idx + 1); + } + + /** + * Approves the supplied PE-connection on the PLS. + * + * @param peConnectionName name of the PE-connection to approve. + * @return the updated {@link PrivateEndpointConnectionInner}. + */ + protected PrivateEndpointConnectionInner approvePrivateEndpointConnection(String peConnectionName) { + PrivateEndpointConnectionInner parameters = new PrivateEndpointConnectionInner() + .withPrivateLinkServiceConnectionState(new PrivateLinkServiceConnectionState().withStatus("Approved") + .withDescription("") + .withActionsRequired("None")); + return networkManager(XDATAMOVE_SYNTHETICS_SUB_ID).serviceClient() + .getPrivateLinkServices() + .updatePrivateEndpointConnection(PRIVATE_LINK_SERVICE_RG, PRIVATE_LINK_SERVICE_NAME, peConnectionName, + parameters); + } + + /** + * Polls the Storage Mover Connection resource until its + * {@link ConnectionStatus} reads {@link ConnectionStatus#APPROVED}. There + * is a 1-5 minute lag between PLS-side approval and the RP propagating the + * status, so we wait up to {@code 10 * 30s = 5 min}. + * + * @param storageMoverName parent storage mover name. + * @param connectionName connection name. + * @return the connection once status is {@code Approved}. + * @throws IllegalStateException if status does not reach {@code Approved} + * within the polling window. + */ + protected Connection waitForConnectionApproved(String storageMoverName, String connectionName) { + for (int attempt = 0; attempt < 10; attempt++) { + Connection refreshed + = storageMoverManager.connections().get(resourceGroupName, storageMoverName, connectionName); + if (refreshed.properties() != null + && ConnectionStatus.APPROVED.equals(refreshed.properties().connectionStatus())) { + return refreshed; + } + sleep(Duration.ofSeconds(30)); + } + throw new IllegalStateException("Connection " + connectionName + " did not reach Approved within 5 minutes"); + } + + /** + * Assigns {@code Storage Blob Data Contributor} to the supplied principal + * id on the given scope. MSI propagation can lag for several seconds after + * an Endpoint create returns, so we retry up to {@code 10 * 6s = 60s} on + * {@code PrincipalNotFound}. {@code RoleAssignmentExists} is treated as + * idempotent success. + * + * @param principalId MSI principal id from the endpoint create response. + * @param scope full ARM scope (e.g. a container resource id). + * @return the role-assignment GUID (the {@code name} of the role + * assignment) for cleanup; never {@code null}. + */ + protected String assignBlobDataContributorWithRetry(String principalId, String scope) { + String roleAssignmentName = generateRandomUuid(); + ManagementException lastError = null; + for (int attempt = 0; attempt < 10; attempt++) { + try { + authorizationManager(XDATAMOVE_SYNTHETICS_SUB_ID).roleAssignments() + .define(roleAssignmentName) + .forObjectId(principalId) + .withBuiltInRole(BuiltInRole.STORAGE_BLOB_DATA_CONTRIBUTOR) + .withScope(scope) + .create(); + return roleAssignmentName; + } catch (ManagementException ex) { + String code = ex.getValue() != null ? ex.getValue().getCode() : null; + if ("RoleAssignmentExists".equalsIgnoreCase(code)) { + return roleAssignmentName; + } + if (!"PrincipalNotFound".equalsIgnoreCase(code)) { + throw ex; + } + lastError = ex; + sleep(Duration.ofSeconds(6)); + } + } + throw new IllegalStateException("role assignment never propagated for principal " + principalId, lastError); + } + private static Region parseRegionOrDefault(String name, Region fallback) { if (CoreUtils.isNullOrEmpty(name)) { return fallback; From aadba5e638602b7d608dbd14e4fd1ccc7f3d86a2 Mon Sep 17 00:00:00 2001 From: Suyash Choudhary Date: Fri, 29 May 2026 12:42:30 +0530 Subject: [PATCH 5/6] Update assets.json tag and enhance Connection and JobDefinition schedule tests for improved validation --- .../assets.json | 2 +- .../scenario/ConnectionTests.java | 24 +++++-- .../scenario/JobDefinitionScheduleTests.java | 8 +-- .../StorageMoverManagementTestBase.java | 65 ++++++++++--------- 4 files changed, 60 insertions(+), 39 deletions(-) diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/assets.json b/sdk/storagemover/azure-resourcemanager-storagemover/assets.json index 12453dfabf4b..6c4d1df06042 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/assets.json +++ b/sdk/storagemover/azure-resourcemanager-storagemover/assets.json @@ -2,5 +2,5 @@ "AssetsRepo": "Azure/azure-sdk-assets", "AssetsRepoPrefixPath": "java", "TagPrefix": "java/storagemover/azure-resourcemanager-storagemover", - "Tag": "java/storagemover/azure-resourcemanager-storagemover_f2516d6925" + "Tag": "java/storagemover/azure-resourcemanager-storagemover_afaadc7d3b" } diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ConnectionTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ConnectionTests.java index 10c7d2d19af0..96f84dc76497 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ConnectionTests.java +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/ConnectionTests.java @@ -59,16 +59,30 @@ public void createGetListUpdateDelete() { Assertions.assertEquals(connectionName, created.name()); Assertions.assertNotNull(created.properties()); Assertions.assertEquals("initial description", created.properties().description()); - Assertions.assertEquals(PRIVATE_LINK_SERVICE_ID, created.properties().privateLinkServiceId()); + // The body-key sanitizer registered in the base redacts the + // subscription segment of $..privateLinkServiceId to all-zeros, so + // assert only the resource-group + name suffix (which is what the + // round-trip actually verifies). The sub segment is identical in + // record and playback after sanitization. + String expectedPlsSuffix = "/resourceGroups/" + PRIVATE_LINK_SERVICE_RG + + "/providers/Microsoft.Network/privateLinkServices/" + PRIVATE_LINK_SERVICE_NAME; + Assertions.assertNotNull(created.properties().privateLinkServiceId()); + Assertions.assertTrue(created.properties().privateLinkServiceId().endsWith(expectedPlsSuffix), + "expected privateLinkServiceId to end with " + expectedPlsSuffix + " but was " + + created.properties().privateLinkServiceId()); Connection fetched = storageMoverManager.connections().get(resourceGroupName, sm.name(), connectionName); Assertions.assertEquals(connectionName, fetched.name()); - Assertions.assertEquals(PRIVATE_LINK_SERVICE_ID, fetched.properties().privateLinkServiceId()); + Assertions.assertNotNull(fetched.properties().privateLinkServiceId()); + Assertions.assertTrue(fetched.properties().privateLinkServiceId().endsWith(expectedPlsSuffix), + "expected fetched privateLinkServiceId to end with " + expectedPlsSuffix + " but was " + + fetched.properties().privateLinkServiceId()); - long count = StreamSupport + boolean foundConnection = StreamSupport .stream(storageMoverManager.connections().list(resourceGroupName, sm.name()).spliterator(), false) - .count(); - Assertions.assertTrue(count >= 1, "expected at least one connection but found " + count); + .anyMatch(c -> connectionName.equals(c.name())); + Assertions.assertTrue(foundConnection, + "expected connection " + connectionName + " in list but it was not found"); // Update keeps the same PLS id (cannot be changed post-create) and // changes only the description. The new description is intentionally diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java index 4c480c8e65d2..48f355671b2c 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/JobDefinitionScheduleTests.java @@ -26,10 +26,10 @@ * *

All schedule {@code startDate}/{@code endDate} values are derived from * {@link #scheduleStartDate()} (a {@code Z}-offset {@code OffsetDateTime} of - * {@code now() + 1 day}, sanitized in recordings to a fixed placeholder so - * playback is deterministic) so playback recordings stay portable and the - * server does not see the {@code +00:00}-suffix that triggers an RP bug — see - * the cross-language playbook. + * {@code now() + 1 day} captured via {@code testResourceNamer.now()} so the + * value is recorded once and replayed deterministically) so playback recordings + * stay portable and the server does not see the {@code +00:00}-suffix that + * triggers an RP bug — see the cross-language playbook. */ public class JobDefinitionScheduleTests extends StorageMoverManagementTestBase { diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java index 79297c32b3cd..413672548577 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java @@ -37,7 +37,6 @@ import java.time.Duration; import java.time.OffsetDateTime; -import java.time.ZoneOffset; import java.time.temporal.ChronoUnit; import java.util.ArrayList; import java.util.Arrays; @@ -70,28 +69,21 @@ public abstract class StorageMoverManagementTestBase extends ResourceManagerTest */ protected static final Region WEST_CENTRAL_US = Region.US_WEST_CENTRAL; - /** - * Placeholder value the {@code $..startDate} / {@code $..endDate} body-key - * sanitizers rewrite all schedule dates to. Both the stored recording and - * the live request body during playback get this value, so playback matches - * succeed regardless of when the test is run. - */ - private static final String REDACTED_SCHEDULE_DATE = "2030-01-01T00:00:00Z"; - /** * Returns a {@code startDate} suitable for schedule tests. * *

The Storage Mover RP rejects any {@code endDate} more than one year * past wall-clock {@code now()}, so a hard-coded far-future date does not - * work. The body-key sanitizer registered in {@link #beforeTest} rewrites - * the value to {@link #REDACTED_SCHEDULE_DATE} in both the stored recording - * and the live request during playback, keeping the recordings portable. + * work. Uses {@link com.azure.core.test.utils.TestResourceNamer#now()} + * which records the value during {@code RECORD} mode and replays the + * same value during {@code PLAYBACK}, keeping recordings portable across + * dates without an extra body-key sanitizer. * * @return a UTC {@link OffsetDateTime} one day in the future, truncated to * the day so the JSON payload is stable. */ - protected static OffsetDateTime scheduleStartDate() { - return OffsetDateTime.now(ZoneOffset.UTC).plusDays(1).truncatedTo(ChronoUnit.DAYS); + protected OffsetDateTime scheduleStartDate() { + return testResourceNamer.now().plusDays(1).truncatedTo(ChronoUnit.DAYS); } /** @@ -209,20 +201,26 @@ protected HttpPipeline buildHttpPipeline(TokenCredential credential, AzureProfil @Override protected void beforeTest() { - // Schedule dates are dynamic ("now + N days") so the RP accepts them, - // but we sanitize them to a fixed placeholder so recordings replay on - // any date. The sanitizer is bidirectional: applied both when storing - // recordings and when matching incoming requests during playback. - // Cross-sub principalIds and PE names are server-generated per-run and - // must be redacted in body too — URL sub-id sanitization is already - // handled by the framework's default sanitizers. + // Cross-sub principalIds, tenantIds, and any custom resource-id-typed + // properties in the body are server-generated per-run and must be + // redacted from the persisted recordings. URL-side subscription-id + // sanitization is handled by the framework's default sanitizers. + // + // The two ARM-id fields ($..privateLinkServiceId and + // $..privateEndpointResourceId) carry full /subscriptions/.../ paths + // referencing the shared XDataMove-Synthetics sub and the cross-sub + // PE-provisioning sub respectively. The default URL sanitizer does not + // reach these custom property names — sanitize them explicitly here so + // real subscription IDs never make it into azure-sdk-assets. interceptorManager.addSanitizers(Arrays.asList( - new TestProxySanitizer("$..startDate", null, REDACTED_SCHEDULE_DATE, TestProxySanitizerType.BODY_KEY), - new TestProxySanitizer("$..endDate", null, REDACTED_SCHEDULE_DATE, TestProxySanitizerType.BODY_KEY), new TestProxySanitizer("$..principalId", null, "00000000-0000-0000-0000-000000000000", TestProxySanitizerType.BODY_KEY), new TestProxySanitizer("$..tenantId", null, "00000000-0000-0000-0000-000000000000", - TestProxySanitizerType.BODY_KEY))); + TestProxySanitizerType.BODY_KEY), + new TestProxySanitizer("$..privateLinkServiceId", SUBSCRIPTION_ID_IN_RESOURCE_ID_REGEX, + "/subscriptions/00000000-0000-0000-0000-000000000000", TestProxySanitizerType.BODY_KEY), + new TestProxySanitizer("$..privateEndpointResourceId", SUBSCRIPTION_ID_IN_RESOURCE_ID_REGEX, + "/subscriptions/00000000-0000-0000-0000-000000000000", TestProxySanitizerType.BODY_KEY))); super.beforeTest(); } @@ -259,16 +257,25 @@ protected void cleanUpResources() { } } + /** + * Regex matching the subscription-id segment of an ARM resource id. Used by + * body-key sanitizers to redact only the subscription portion while keeping + * the rest of the URL (resource group, resource type, name) intact for + * cross-checking. + */ + private static final String SUBSCRIPTION_ID_IN_RESOURCE_ID_REGEX + = "/subscriptions/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"; + /** * Asserts that the given operation throws a {@link ManagementException} - * carrying an HTTP status code in {@code [400, 500)}. Used as the Java - * analogue of .NET's {@code Assert.IsFalse(await coll.ExistsAsync(name))} - * pattern (where the SDK does not surface an {@code Exists} helper). + * carrying the expected HTTP status code. Used as the Java analogue of + * .NET's {@code Assert.IsFalse(await coll.ExistsAsync(name))} pattern + * (where the SDK does not surface an {@code Exists} helper). * * @param expectedStatus expected HTTP status (typically 404). * @param action the operation that should throw. */ - protected static void assertHttpStatus(int expectedStatus, Runnable action) { + protected static void assertManagementExceptionAndHttpStatus(int expectedStatus, Runnable action) { ManagementException ex = Assertions.assertThrows(ManagementException.class, action::run); Assertions.assertEquals(expectedStatus, ex.getResponse().getStatusCode(), "expected HTTP " + expectedStatus + " but got " + ex.getResponse().getStatusCode() + " — body: " + ex.getValue()); @@ -280,7 +287,7 @@ protected static void assertHttpStatus(int expectedStatus, Runnable action) { * @param action the operation that should produce a 404. */ protected static void assertNotFound(Runnable action) { - assertHttpStatus(404, action); + assertManagementExceptionAndHttpStatus(404, action); } /** From 9f858793693946184ed4780725ca47f437c590b7 Mon Sep 17 00:00:00 2001 From: Suyash Choudhary Date: Fri, 29 May 2026 13:07:21 +0530 Subject: [PATCH 6/6] Address review: drop unused role-id constant and honor test delay provider for StorageMoverManager LROs - Remove unused STORAGE_BLOB_DATA_CONTRIBUTOR_ROLE_ID constant. - Build StorageMoverManager via reflection on its 3-arg constructor so defaultPollInterval is sourced from InternalRuntimeContext, letting TestDelayProvider collapse LRO polling delays in playback. Cuts full-module playback from ~7 min to ~1 min. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../StorageMoverManagementTestBase.java | 40 ++++++++++++++----- 1 file changed, 30 insertions(+), 10 deletions(-) diff --git a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java index 413672548577..4d0ce72304ff 100644 --- a/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java +++ b/sdk/storagemover/azure-resourcemanager-storagemover/src/test/java/com/azure/resourcemanager/storagemover/scenario/StorageMoverManagementTestBase.java @@ -35,6 +35,7 @@ import com.azure.resourcemanager.test.utils.TestDelayProvider; import org.junit.jupiter.api.Assertions; +import java.lang.reflect.Constructor; import java.time.Duration; import java.time.OffsetDateTime; import java.time.temporal.ChronoUnit; @@ -133,12 +134,6 @@ protected OffsetDateTime scheduleStartDate() { = "/subscriptions/" + XDATAMOVE_SYNTHETICS_SUB_ID + "/resourceGroups/" + TEST_STORAGE_ACCOUNT_RG + "/providers/Microsoft.Storage/storageAccounts/" + TEST_STORAGE_ACCOUNT_NAME; - /** - * Built-in {@code Storage Blob Data Contributor} role definition GUID - * (subscription-scope role-definition id is composed by the helper). - */ - protected static final String STORAGE_BLOB_DATA_CONTRIBUTOR_ROLE_ID = "ba92f5b4-2d11-453d-a403-e96b0029c9fe"; - /** * Placeholder storage account resource id used when an endpoint requires a * storage-account ARM id but the test does not actually hit the storage @@ -231,10 +226,12 @@ protected void initializeClients(HttpPipeline httpPipeline, AzureProfile profile this.sharedHttpPipeline = httpPipeline; this.sharedTestProfile = profile; - // StorageMoverManager has no public 2-arg constructor, so the generic - // buildManager() helper from the base does not work — use the static - // authenticate factory instead. - storageMoverManager = StorageMoverManager.authenticate(httpPipeline, profile); + // StorageMoverManager does not consult InternalRuntimeContext.delayProvider, so + // the static authenticate factory leaves defaultPollInterval = null and playback + // waits the recorded LRO duration on every poll. Build the manager via its + // private 3-arg constructor so the test delay provider can collapse it. + // Track removal once https://github.com/Azure/azure-sdk-for-java/issues/49294 lands. + storageMoverManager = buildStorageMoverManager(httpPipeline, profile); resourceManager = ResourceManager.authenticate(httpPipeline, profile).withDefaultSubscription(); // Now that ResourceManager exists we can hand its provider collection to @@ -257,6 +254,29 @@ protected void cleanUpResources() { } } + /** + * Builds a {@link StorageMoverManager} via its package-private 3-arg + * constructor so a test-managed {@code defaultPollInterval} can be supplied. + * Mirrors {@link ResourceManagerTestProxyTestBase#buildManager} but targets + * the {@code (HttpPipeline, AzureProfile, Duration)} signature that the + * generated manager exposes. + * + * @param httpPipeline shared test pipeline. + * @param profile shared azure profile. + * @return a manager whose LROs honour the test delay provider. + */ + private static StorageMoverManager buildStorageMoverManager(HttpPipeline httpPipeline, AzureProfile profile) { + try { + Constructor constructor = StorageMoverManager.class + .getDeclaredConstructor(HttpPipeline.class, AzureProfile.class, Duration.class); + constructor.setAccessible(true); + return constructor.newInstance(httpPipeline, profile, + ResourceManagerUtils.InternalRuntimeContext.getDelayDuration(Duration.ofSeconds(30))); + } catch (ReflectiveOperationException ex) { + throw new RuntimeException(ex); + } + } + /** * Regex matching the subscription-id segment of an ARM resource id. Used by * body-key sanitizers to redact only the subscription portion while keeping