public async Task ManagedHsmRecoverDeletedVault()
{
Location = "westus";
var parameters = new ManagedHsmData(Location)
{
Sku = new ManagedHsmSku(ManagedHsmSkuFamily.B, ManagedHsmSkuName.StandardB1),
Properties = ManagedHsmProperties
};
parameters.Tags.InitializeFrom(Tags);
var managedHsm = await ManagedHsmContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false);
// Delete
await managedHsm.Value.DeleteAsync();
// Get deleted vault
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await ManagedHsmContainer.GetAsync(VaultName);
});
parameters.Properties.CreateMode = CreateMode.Recover;
// Recover in recover mode
var recoveredVault2 = await ManagedHsmContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false);
Assert.True(recoveredVault2.Value.Data.IsEqual(managedHsm.Value.Data));
// Get recovered vault
var getResult = await ManagedHsmContainer.GetAsync(VaultName);
// Delete
await getResult.Value.DeleteAsync();
}
ManagedHsm IOperationSource <ManagedHsm> .CreateResult(Response response, CancellationToken cancellationToken)
{
using var document = JsonDocument.Parse(response.ContentStream);
var data = ManagedHsmData.DeserializeManagedHsmData(document.RootElement);
return(new ManagedHsm(_armClient, data));
}
public async Task ManagedHsmRecoverDeletedVault()
{
ManagedHsmData parameters = new ManagedHsmData(Location)
{
Sku = new ManagedHsmSku(ManagedHsmSkuFamily.B, ManagedHsmSkuName.StandardB1),
Properties = ManagedHsmProperties
};
parameters.Tags.InitializeFrom(Tags);
ArmOperation <ManagedHsmResource> managedHsm = await ManagedHsmCollection.CreateOrUpdateAsync(WaitUntil.Completed, MHSMName, parameters).ConfigureAwait(false);
// Delete
await managedHsm.Value.DeleteAsync(WaitUntil.Completed);
// Get deleted vault
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await ManagedHsmCollection.GetAsync(MHSMName);
});
parameters.Properties.CreateMode = CreateMode.Recover;
// Recover in recover mode
ArmOperation <ManagedHsmResource> recoveredVault2 = await ManagedHsmCollection.CreateOrUpdateAsync(WaitUntil.Completed, MHSMName, parameters).ConfigureAwait(false);
Assert.True(recoveredVault2.Value.Data.IsEqual(managedHsm.Value.Data));
// Get recovered vault
Response <ManagedHsmResource> getResult = await ManagedHsmCollection.GetAsync(MHSMName);
// Delete
await getResult.Value.DeleteAsync(WaitUntil.Completed);
}
internal static ManagedHsmListResult DeserializeManagedHsmListResult(JsonElement element)
{
Optional <IReadOnlyList <ManagedHsmData> > value = default;
Optional <string> nextLink = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("value"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
List <ManagedHsmData> array = new List <ManagedHsmData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(ManagedHsmData.DeserializeManagedHsmData(item));
}
value = array;
continue;
}
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
}
return(new ManagedHsmListResult(Optional.ToList(value), nextLink.Value));
}
private void ValidateVault(
ManagedHsmData managedHsmData,
string expectedVaultName,
string expectedResourceGroupName,
string expectedSubId,
Guid expectedTenantId,
string expectedLocation,
ManagedHsmSkuFamily expectedSkuFamily,
ManagedHsmSkuName expectedSkuName,
CreateMode expectedCreateMode,
bool expectedEnablePurgeProtection,
bool expectedEnableSoftDelete,
List <string> expectedInitialAdminObjectIds,
MhsmNetworkRuleSet expectedNetworkAcls,
PublicNetworkAccess expectedPublicNetworkAccess,
DateTimeOffset expectedScheduledPurgeDate,
int expectedSoftDeleteRetentionInDays,
Dictionary <string, string> expectedTags)
{
Assert.NotNull(managedHsmData);
Assert.NotNull(managedHsmData.Properties);
string resourceIdFormat = "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.KeyVault/managedHSMs/{2}";
string expectedResourceId = string.Format(resourceIdFormat, expectedSubId, expectedResourceGroupName, expectedVaultName);
string expectedHsmUri = $"https://{expectedVaultName}.managedhsm.azure.net/";
Assert.AreEqual(expectedResourceId, managedHsmData.Id.ToString());
Assert.AreEqual(expectedLocation, managedHsmData.Location.ToString());
Assert.AreEqual(expectedTenantId, managedHsmData.Properties.TenantId);
Assert.AreEqual(expectedVaultName, managedHsmData.Name);
Assert.AreEqual(expectedSkuFamily, managedHsmData.Sku.Family);
Assert.AreEqual(expectedSkuName, managedHsmData.Sku.Name);
//Assert.AreEqual(expectedCreateMode, managedHsmData.Properties.CreateMode);
Assert.AreEqual(expectedEnablePurgeProtection, managedHsmData.Properties.EnablePurgeProtection);
Assert.AreEqual(expectedEnableSoftDelete, managedHsmData.Properties.EnableSoftDelete);
Assert.AreEqual(expectedHsmUri, managedHsmData.Properties.HsmUri);
Assert.AreEqual(expectedInitialAdminObjectIds, managedHsmData.Properties.InitialAdminObjectIds);
Assert.AreEqual(expectedNetworkAcls.Bypass, managedHsmData.Properties.NetworkAcls.Bypass);
Assert.AreEqual(expectedNetworkAcls.DefaultAction, managedHsmData.Properties.NetworkAcls.DefaultAction);
//Assert.AreEqual(expectedPrivateEndpointConnections, managedHsmData.Properties.PrivateEndpointConnections);
Assert.AreEqual(expectedPublicNetworkAccess, managedHsmData.Properties.PublicNetworkAccess);
//Assert.AreEqual(expectedScheduledPurgeDate, managedHsmData.Properties.ScheduledPurgeDate);
Assert.AreEqual(expectedSoftDeleteRetentionInDays, managedHsmData.Properties.SoftDeleteRetentionInDays);
Assert.True(expectedTags.DictionaryEqual(managedHsmData.Tags));
}
public async Task ManagedHsmListKeys()
{
List <string> resourceIds = new List <string>();
List <ManagedHsm> vaultList = new List <ManagedHsm>();
Location = "westus";
string vaultName = Recording.GenerateAssetName("sdktestvault");
var parameters = new ManagedHsmData(Location)
{
Sku = new ManagedHsmSku(ManagedHsmSkuFamily.B, ManagedHsmSkuName.StandardB1),
Properties = ManagedHsmProperties
};
parameters.Tags.InitializeFrom(Tags);
var managedHsm = await ManagedHsmContainer.CreateOrUpdateAsync(vaultName, parameters).ConfigureAwait(false);
Assert.NotNull(managedHsm.Value);
Assert.NotNull(managedHsm.Value.Id);
resourceIds.Add(managedHsm.Value.Id);
vaultList.Add(managedHsm.Value);
var vaults = ManagedHsmContainer.GetAllAsync();
await foreach (var v in vaults)
{
Assert.True(resourceIds.Remove(v.Id));
}
Assert.True(resourceIds.Count == 0);
// Delete
foreach (var item in vaultList)
{
await item.DeleteAsync();
// Purge need to use loaction parameter. Update them later.
//await item.PurgeDeletedAsync();
}
}
public static bool IsEqual(this ManagedHsmData vault1, ManagedHsmData vault2)
{
Assert.AreEqual(vault2.Location, vault1.Location);
Assert.AreEqual(vault2.Name, vault1.Name);
Assert.AreEqual(vault2.Id, vault1.Id);
Assert.True(vault2.Tags.DictionaryEqual(vault1.Tags));
Assert.AreEqual(vault2.Properties.HsmUri.ToString().TrimEnd('/'), vault1.Properties.HsmUri.ToString().TrimEnd('/'));
Assert.AreEqual(vault2.Properties.TenantId, vault1.Properties.TenantId);
Assert.AreEqual(vault2.Sku.Name, vault1.Sku.Name);
Assert.AreEqual(vault2.Sku.Family, vault1.Sku.Family);
Assert.AreEqual(vault2.Properties.EnableSoftDelete, vault1.Properties.EnableSoftDelete);
//Assert.AreEqual(vault2.Properties.CreateMode, vault1.Properties.CreateMode);
Assert.AreEqual(vault2.Properties.EnablePurgeProtection, vault1.Properties.EnablePurgeProtection);
Assert.AreEqual(vault2.Properties.InitialAdminObjectIds, vault1.Properties.InitialAdminObjectIds);
//Assert.AreEqual(vault2.Properties.PrivateEndpointConnections, vault1.Properties.PrivateEndpointConnections);
Assert.AreEqual(vault2.Properties.PublicNetworkAccess, vault1.Properties.PublicNetworkAccess);
//Assert.AreEqual(vault2.Properties.ScheduledPurgeDate, vault1.Properties.ScheduledPurgeDate);
Assert.AreEqual(vault2.Properties.SoftDeleteRetentionInDays, vault1.Properties.SoftDeleteRetentionInDays);
Assert.AreEqual(vault2.Properties.TenantId, vault1.Properties.TenantId);
//Assert.True(vault2.Properties.NetworkAcls.IsEqual(vault1.Properties.NetworkAcls));
return(true);
}
public async Task ManagedHsmCreateUpdateDelete()
{
Location = "southcentralus";
var parameters = new ManagedHsmData(Location)
{
Sku = new ManagedHsmSku(ManagedHsmSkuFamily.B, ManagedHsmSkuName.StandardB1),
Properties = ManagedHsmProperties
};
parameters.Tags.InitializeFrom(Tags);
var managedHsm = await ManagedHsmContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false);
ValidateVault(managedHsm.Value.Data,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
ManagedHsmSkuFamily.B,
ManagedHsmSkuName.StandardB1,
CreateMode.Default,
false,
true,
new List <string> {
ObjectId
},
ManagedHsmProperties.NetworkAcls,
PublicNetworkAccess.Disabled,
new DateTimeOffset(2008, 5, 1, 8, 6, 32, new TimeSpan(1, 0, 0)),
10,
Tags);
ManagedHsmProperties.PublicNetworkAccess = PublicNetworkAccess.Enabled;
ManagedHsmProperties.NetworkAcls.DefaultAction = "Allow";
parameters = new ManagedHsmData(Location)
{
Sku = new ManagedHsmSku(ManagedHsmSkuFamily.B, ManagedHsmSkuName.StandardB1),
Properties = ManagedHsmProperties
};
parameters.Tags.InitializeFrom(Tags);
ManagedHsm updateManagedHsm = null;
if (Mode == RecordedTestMode.Record)
{
for (int i = 0; i < 10; i++)
{
try
{
updateManagedHsm = (await ManagedHsmContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false)).Value;
break;
}
catch (Exception)
{
Thread.Sleep(120000);
}
}
}
else
{
for (int i = 0; i < 10; i++)
{
try
{
updateManagedHsm = (await ManagedHsmContainer.CreateOrUpdateAsync(VaultName, parameters).ConfigureAwait(false)).Value;
break;
}
catch (Exception)
{
}
}
}
ValidateVault(updateManagedHsm.Data,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
ManagedHsmSkuFamily.B,
ManagedHsmSkuName.StandardB1,
CreateMode.Default,
false,
true,
new List <string> {
ObjectId
},
ManagedHsmProperties.NetworkAcls,
PublicNetworkAccess.Enabled,
new DateTimeOffset(2008, 5, 1, 8, 6, 32, new TimeSpan(1, 0, 0)),
10,
Tags);
var retrievedVault = await ManagedHsmContainer.GetAsync(VaultName);
ValidateVault(retrievedVault.Value.Data,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
ManagedHsmSkuFamily.B,
ManagedHsmSkuName.StandardB1,
CreateMode.Default,
false,
true,
new List <string> {
ObjectId
},
ManagedHsmProperties.NetworkAcls,
PublicNetworkAccess.Enabled,
new DateTimeOffset(2008, 5, 1, 8, 6, 32, new TimeSpan(1, 0, 0)),
10,
Tags);
// Delete
await retrievedVault.Value.DeleteAsync();
//Purge need to use loaction parameter. Update them later.
//await retrievedVault.Value.PurgeDeletedAsync();
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await ManagedHsmContainer.GetAsync(VaultName);
});
}
public async Task ManagedHsmFull()
{
ManagedHsmData parameters = new ManagedHsmData(Location)
{
Sku = new ManagedHsmSku(ManagedHsmSkuFamily.B, ManagedHsmSkuName.StandardB1),
Properties = ManagedHsmProperties
};
parameters.Tags.InitializeFrom(Tags);
// Create a MHSM
ArmOperation <ManagedHsmResource> managedHsm = await ManagedHsmCollection.CreateOrUpdateAsync(WaitUntil.Completed, MHSMName, parameters).ConfigureAwait(false);
Assert.NotNull(managedHsm.Value);
Assert.NotNull(managedHsm.Value.Id);
ValidateVault(managedHsm.Value.Data,
MHSMName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
ManagedHsmSkuFamily.B,
ManagedHsmSkuName.StandardB1,
false,
true,
new List <string> {
ObjectId
},
ManagedHsmProperties.NetworkRuleSet,
PublicNetworkAccess.Disabled,
DefSoftDeleteRetentionInDays,
Tags);
// List
AsyncPageable <ManagedHsmResource> vaults = ManagedHsmCollection.GetAllAsync();
int count = 0;
await foreach (ManagedHsmResource v in vaults)
{
if (v.Id == managedHsm.Value.Id)
{
count++;
break;
}
}
Assert.True(count == 1);
// Update
ManagedHsmProperties.PublicNetworkAccess = PublicNetworkAccess.Enabled;
ManagedHsmProperties.NetworkRuleSet.DefaultAction = "Allow";
parameters = new ManagedHsmData(Location)
{
Sku = new ManagedHsmSku(ManagedHsmSkuFamily.B, ManagedHsmSkuName.StandardB1),
Properties = ManagedHsmProperties
};
parameters.Tags.InitializeFrom(Tags);
ManagedHsmResource updateManagedHsm = null;
if (Mode == RecordedTestMode.Record)
{
for (int i = 0; i < 10; i++)
{
try
{
updateManagedHsm = (await ManagedHsmCollection.CreateOrUpdateAsync(WaitUntil.Completed, MHSMName, parameters).ConfigureAwait(false)).Value;
break;
}
catch (Exception)
{
Thread.Sleep(120000);
}
}
}
else
{
for (int i = 0; i < 10; i++)
{
try
{
updateManagedHsm = (await ManagedHsmCollection.CreateOrUpdateAsync(WaitUntil.Completed, MHSMName, parameters).ConfigureAwait(false)).Value;
break;
}
catch (Exception)
{
}
}
}
// Get
Response <ManagedHsmResource> retrievedVault = await ManagedHsmCollection.GetAsync(MHSMName);
ValidateVault(retrievedVault.Value.Data,
MHSMName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
ManagedHsmSkuFamily.B,
ManagedHsmSkuName.StandardB1,
false,
true,
new List <string> {
ObjectId
},
ManagedHsmProperties.NetworkRuleSet,
PublicNetworkAccess.Enabled,
DefSoftDeleteRetentionInDays,
Tags);
// Delete
await retrievedVault.Value.DeleteAsync(WaitUntil.Completed);
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await ManagedHsmCollection.GetAsync(MHSMName);
});
// Try to purge
try
{
Response <DeletedManagedHsmResource> deletedMhsm = await Subscription.GetDeletedManagedHsmAsync(Location, MHSMName);
Assert.NotNull(managedHsm.Value);
await deletedMhsm.Value.PurgeDeletedAsync(WaitUntil.Completed);
}
catch (Exception)
{
}
}
