public override void ExecuteCmdlet()
{
if (ShouldProcess(Name, DPSResources.RemoveLinkedHub))
{
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.ResourceGroupName;
this.Name = this.InputObject.Name;
this.LinkedHubName = this.InputObject.LinkedHubName;
}
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotDpsUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotDpsUtils.GetIotDpsName(this.ResourceId);
}
ProvisioningServiceDescription provisioningServiceDescription = GetIotDpsResource(this.ResourceGroupName, this.Name);
IList <IotHubDefinitionDescription> linkedHubs = GetIotDpsHubs(this.ResourceGroupName, this.Name);
IotHubDefinitionDescription linkedHub = linkedHubs.FirstOrDefault(hubs => hubs.Name.Equals(this.LinkedHubName));
provisioningServiceDescription.Properties.IotHubs = linkedHubs.Where(x => x.ConnectionString != linkedHub.ConnectionString).ToList();
IotDpsCreateOrUpdate(this.ResourceGroupName, this.Name, provisioningServiceDescription);
if (PassThru)
{
this.WriteObject(true);
}
}
}
public async Task CreateFailure()
{
using var context = MockContext.Start(GetType());
Initialize(context);
const string testName = "unitTestingDPSCreateUpdateInvalidName";
ResourceGroup rg = await GetResourceGroupAsync(testName).ConfigureAwait(false);
// try to create a DPS service
var createServiceDescription = new ProvisioningServiceDescription(
Constants.DefaultLocation,
new IotDpsPropertiesDescription(),
new IotDpsSkuInfo(Constants.DefaultSku.Name,
Constants.DefaultSku.Tier,
Constants.DefaultSku.Capacity));
var badCall = new Func <Task <ProvisioningServiceDescription> >(
() =>
// force a failure by passing bad input
_provisioningClient.IotDpsResource.CreateOrUpdateAsync(
rg.Name,
// Must be between 3 and 64 characters, must not be a number, must be alphanumeric/dash characters, and must be unique
$"Invalid {testName}",
createServiceDescription));
await badCall.Should().ThrowAsync <ErrorDetailsException>();
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(Name, DPSResources.RemoveAccessPolicy))
{
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.InputObject.ResourceGroupName;
this.Name = this.InputObject.Name;
this.KeyName = this.InputObject.KeyName;
}
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotDpsUtils.GetResourceGroupName(this.ResourceId);
this.Name = IotDpsUtils.GetIotDpsName(this.ResourceId);
}
ProvisioningServiceDescription provisioningServiceDescription = GetIotDpsResource(this.ResourceGroupName, this.Name);
IList <SharedAccessSignatureAuthorizationRuleAccessRightsDescription> currentIotDpsAccessPolicyList = GetIotDpsAccessPolicy(this.ResourceGroupName, this.Name);
SharedAccessSignatureAuthorizationRuleAccessRightsDescription iotDpsAccessPolicy = GetIotDpsAccessPolicy(this.ResourceGroupName, this.Name, this.KeyName);
IList <SharedAccessSignatureAuthorizationRuleAccessRightsDescription> updatedIotDpsAccessPolicyList = currentIotDpsAccessPolicyList.Where(x => x.KeyName != iotDpsAccessPolicy.KeyName).ToList();
provisioningServiceDescription.Properties.AuthorizationPolicies = updatedIotDpsAccessPolicyList;
IotDpsCreateOrUpdate(this.ResourceGroupName, this.Name, provisioningServiceDescription);
if (PassThru)
{
this.WriteObject(true);
}
}
}
protected async Task <ProvisioningServiceDescription> GetServiceAsync(string resourceGroupName, string serviceName)
{
NameAvailabilityInfo availabilityInfo = await _provisioningClient.IotDpsResource
.CheckProvisioningServiceNameAvailabilityAsync(serviceName)
.ConfigureAwait(false);
if (availabilityInfo.NameAvailable.HasValue && !availabilityInfo.NameAvailable.Value)
{
_provisioningClient.IotDpsResource.Get(serviceName, resourceGroupName);
}
var createServiceDescription = new ProvisioningServiceDescription(
Constants.DefaultLocation,
new IotDpsPropertiesDescription(),
new IotDpsSkuInfo(
Constants.DefaultSku.Name,
Constants.DefaultSku.Tier,
Constants.DefaultSku.Capacity));
return(await _provisioningClient.IotDpsResource
.CreateOrUpdateAsync(
resourceGroupName,
serviceName,
createServiceDescription)
.ConfigureAwait(false));
}
//[Fact]
public void CreateFailure()
{
using (var context = MockContext.Start(this.GetType().FullName))
{
this.Initialize(context);
var testName = "unitTestingDPSCreateUpdateInvalidName";
this.GetResourceGroup(testName);
//try to create a DPS service
var createServiceDescription = new ProvisioningServiceDescription(Constants.DefaultLocation,
new IotDpsPropertiesDescription(),
new IotDpsSkuInfo(Constants.DefaultSku.Name,
Constants.DefaultSku.Tier,
Constants.DefaultSku.Capacity
));
var badCall = new Func <ProvisioningServiceDescription>(() => this.provisioningClient.IotDpsResource.CreateOrUpdate(
testName,
$"1ñ1{testName}!!!", //We dont't allow most punctuation, leading numbers, etc
createServiceDescription));
Assert.Throws <ErrorDetailsException>(badCall);
}
}
private void AddIotDpsLinkedHub()
{
IotHubDefinitionDescription iotDpsHub = new IotHubDefinitionDescription()
{
ConnectionString = this.IotHubConnectionString,
Location = this.IotHubLocation,
AllocationWeight = this.AllocationWeight,
ApplyAllocationPolicy = this.ApplyAllocationPolicy.IsPresent
};
ProvisioningServiceDescription provisioningServiceDescription = GetIotDpsResource(this.ResourceGroupName, this.Name);
provisioningServiceDescription.Properties.IotHubs.Add(iotDpsHub);
IotDpsCreateOrUpdate(this.ResourceGroupName, this.Name, provisioningServiceDescription);
IList <IotHubDefinitionDescription> iotDpsHubs = GetIotDpsHubs(this.ResourceGroupName, this.Name);
if (iotDpsHubs.Count == 1)
{
this.WritePSObject(iotDpsHubs[0]);
}
else
{
this.WritePSObjects(iotDpsHubs);
}
}
private void UpdateIotDpsAccessPolicy()
{
ArrayList accessRights = new ArrayList();
PSAccessRightsDescription psAccessRightsDescription;
foreach (string permission in this.Permissions)
{
if (!Enum.TryParse <PSAccessRightsDescription>(permission.Trim(), true, out psAccessRightsDescription))
{
throw new ArgumentException("Invalid access policy permission");
}
else
{
accessRights.Add(psAccessRightsDescription.ToString());
}
}
ProvisioningServiceDescription provisioningServiceDescription = GetIotDpsResource(this.ResourceGroupName, this.Name);
IList <SharedAccessSignatureAuthorizationRuleAccessRightsDescription> iotDpsAccessPolicyList = GetIotDpsAccessPolicy(this.ResourceGroupName, this.Name);
SharedAccessSignatureAuthorizationRuleAccessRightsDescription iotDpsAccessPolicy = GetIotDpsAccessPolicy(this.ResourceGroupName, this.Name, this.KeyName);
foreach (SharedAccessSignatureAuthorizationRuleAccessRightsDescription accessPolicy in iotDpsAccessPolicyList)
{
if (accessPolicy.KeyName.Equals(iotDpsAccessPolicy.KeyName))
{
accessPolicy.Rights = string.Join(", ", accessRights.ToArray());
}
}
provisioningServiceDescription.Properties.AuthorizationPolicies = iotDpsAccessPolicyList;
IotDpsCreateOrUpdate(this.ResourceGroupName, this.Name, provisioningServiceDescription);
this.WriteObject(IotDpsUtils.ToPSSharedAccessSignatureAuthorizationRuleAccessRightsDescription(GetIotDpsAccessPolicy(this.ResourceGroupName, this.Name, this.KeyName), this.ResourceGroupName, this.Name), false);
}
public async Task CreateAndDelete()
{
using MockContext context = MockContext.Start(GetType());
Initialize(context);
var testName = "unitTestingDPSCertificatesCreateAndDelete";
ResourceGroup rg = await GetResourceGroupAsync(testName).ConfigureAwait(false);
ProvisioningServiceDescription service = await GetServiceAsync(testName, rg.Name).ConfigureAwait(false);
//add a cert
await _provisioningClient.DpsCertificate
.CreateOrUpdateAsync(
rg.Name,
testName,
Constants.Certificate.Name,
null,
Constants.Certificate.Content)
.ConfigureAwait(false);
CertificateListDescription certificateList = await _provisioningClient.DpsCertificate
.ListAsync(rg.Name, testName)
.ConfigureAwait(false);
certificateList.Value.Should().Contain(x => x.Name == Constants.Certificate.Name);
// verify certificate details
CertificateResponse certificateDetails = certificateList.Value.FirstOrDefault(x => x.Name == Constants.Certificate.Name);
certificateDetails.Should().NotBeNull();
certificateDetails.Properties.Subject.Should().Be(Constants.Certificate.Subject);
certificateDetails.Properties.Thumbprint.Should().Be(Constants.Certificate.Thumbprint);
// can get a verification code
VerificationCodeResponse verificationCodeResponse = await _provisioningClient.DpsCertificate
.GenerateVerificationCodeAsync(
certificateDetails.Name,
certificateDetails.Etag,
rg.Name,
service.Name)
.ConfigureAwait(false);
verificationCodeResponse.Properties.Should().NotBeNull();
verificationCodeResponse.Properties.VerificationCode.Should().NotBeNullOrEmpty();
// delete certificate
await _provisioningClient.DpsCertificate
.DeleteAsync(
rg.Name,
verificationCodeResponse.Etag,
service.Name,
Constants.Certificate.Name)
.ConfigureAwait(false);
certificateList = await _provisioningClient.DpsCertificate
.ListAsync(rg.Name, testName)
.ConfigureAwait(false);
certificateList.Value.Should().NotContain(x => x.Name == Constants.Certificate.Name);
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(Name, DPSResources.AddDeviceProvisioningService))
{
if (string.IsNullOrEmpty(this.Location))
{
ResourceGroup resourceGroup = ResourceManagementClient.ResourceGroups.Get(this.ResourceGroupName);
this.Location = resourceGroup.Location;
}
var provisioningServiceDescription = new ProvisioningServiceDescription()
{
Location = this.Location,
Properties = new IotDpsPropertiesDescription(),
Sku = new IotDpsSkuInfo()
};
if (this.AllocationPolicy != null)
{
PSAllocationPolicy psAllocationPolicy;
if (Enum.TryParse <PSAllocationPolicy>(this.AllocationPolicy, true, out psAllocationPolicy))
{
provisioningServiceDescription.Properties.AllocationPolicy = psAllocationPolicy.ToString();
}
else
{
throw new ArgumentException("Invalid Allocation Policy");
}
}
if (this.SkuName != null)
{
PSIotDpsSku psIotDpsSku;
if (Enum.TryParse <PSIotDpsSku>(this.SkuName, true, out psIotDpsSku))
{
provisioningServiceDescription.Sku.Name = psIotDpsSku.ToString();
}
else
{
throw new ArgumentException("Invalid Sku");
}
}
else
{
provisioningServiceDescription.Sku = new IotDpsSkuInfo(IotDpsSku.S1);
}
if (this.IsParameterBound(c => c.Tag))
{
provisioningServiceDescription.Tags = this.Tag.Cast <DictionaryEntry>().ToDictionary(kvp => (string)kvp.Key, kvp => (string)kvp.Value);
}
IotDpsCreateOrUpdate(this.ResourceGroupName, this.Name, provisioningServiceDescription);
this.WriteObject(IotDpsUtils.ToPSProvisioningServiceDescription(GetIotDpsResource(this.ResourceGroupName, this.Name)), false);
}
}
private void UpdateIotDpsLinkedHub()
{
ProvisioningServiceDescription provisioningServiceDescription = GetIotDpsResource(this.ResourceGroupName, this.Name);
IotHubDefinitionDescription iotHub = provisioningServiceDescription.Properties.IotHubs.FirstOrDefault(x => x.Name.Equals(this.LinkedHubName, StringComparison.OrdinalIgnoreCase));
iotHub.ApplyAllocationPolicy = this.ApplyAllocationPolicy.IsPresent;
iotHub.AllocationWeight = this.AllocationWeight ?? iotHub.AllocationWeight;
IotDpsCreateOrUpdate(this.ResourceGroupName, this.Name, provisioningServiceDescription);
this.WriteObject(IotDpsUtils.ToPSIotHubDefinitionDescription(GetIotDpsHubs(this.ResourceGroupName, this.Name, this.LinkedHubName), this.ResourceGroupName, this.Name), false);
}
public async Task Get()
{
using var context = MockContext.Start(GetType());
var testName = "unitTestingUpdateAllocationPolicyGet";
Initialize(context);
ResourceGroup resourceGroup = await GetResourceGroupAsync(testName).ConfigureAwait(false);
ProvisioningServiceDescription testedService = await GetServiceAsync(resourceGroup.Name, testName).ConfigureAwait(false);
Constants.AllocationPolicies.Should().Contain(testedService.Properties.AllocationPolicy);
}
private void CreateUpdateIotDps()
{
PSAllocationPolicy psAllocationPolicy;
if (Enum.TryParse <PSAllocationPolicy>(this.AllocationPolicy, true, out psAllocationPolicy))
{
ProvisioningServiceDescription provisioningServiceDescription = GetIotDpsResource(this.ResourceGroupName, this.Name);
provisioningServiceDescription.Properties.AllocationPolicy = psAllocationPolicy.ToString();
this.WritePSObject(IotDpsCreateOrUpdate(this.ResourceGroupName, this.Name, provisioningServiceDescription));
}
else
{
throw new ArgumentException("Invalid Allocation Policy");
}
}
public async Task Update()
{
using var context = MockContext.Start(GetType());
var testName = "unitTestingDPSAllocationPolicyUpdate";
Initialize(context);
ResourceGroup resourceGroup = await GetResourceGroupAsync(testName).ConfigureAwait(false);
ProvisioningServiceDescription testedService = await GetServiceAsync(testName, testName).ConfigureAwait(false);
// get a different allocation policy
var newAllocationPolicy = Constants.AllocationPolicies
.Except(new[] { testedService.Properties.AllocationPolicy })
.First();
int attempts = Constants.ArmAttemptLimit;
while (attempts > 0 &&
testedService.Properties.AllocationPolicy != newAllocationPolicy)
{
testedService.Properties.AllocationPolicy = newAllocationPolicy;
try
{
var updatedInstance = await _provisioningClient.IotDpsResource
.CreateOrUpdateAsync(
resourceGroup.Name,
testName,
testedService)
.ConfigureAwait(false);
newAllocationPolicy.Should().Be(updatedInstance.Properties.AllocationPolicy);
testedService.Properties.AllocationPolicy = updatedInstance.Properties.AllocationPolicy;
}
catch
{
// Let ARM finish
await Task.Delay(Constants.ArmAttemptWaitMs).ConfigureAwait(false);
attempts--;
}
}
}
protected ProvisioningServiceDescription GetService(string serviceName, string resourceGroupName)
{
var availabilityInfo =
this.provisioningClient.IotDpsResource.CheckProvisioningServiceNameAvailability(new OperationInputs(serviceName));
if (!availabilityInfo.NameAvailable ?? true)
{
this.provisioningClient.IotDpsResource.Get(serviceName,
resourceGroupName);
}
var createServiceDescription = new ProvisioningServiceDescription(Constants.DefaultLocation,
new IotDpsPropertiesDescription(),
new IotDpsSkuInfo(Constants.DefaultSku.Name,
Constants.DefaultSku.Tier,
Constants.DefaultSku.Capacity
));
return(this.provisioningClient.IotDpsResource.CreateOrUpdate(
resourceGroupName,
serviceName, createServiceDescription));
}
private void AddIotDpsAccessPolicy()
{
ArrayList accessRights = new ArrayList();
PSAccessRightsDescription psAccessRightsDescription;
foreach (string permission in this.Permissions)
{
if (!Enum.TryParse <PSAccessRightsDescription>(permission.Trim(), true, out psAccessRightsDescription))
{
throw new ArgumentException("Invalid access policy permission");
}
else
{
accessRights.Add(psAccessRightsDescription.ToString());
}
}
SharedAccessSignatureAuthorizationRuleAccessRightsDescription iotDpsAccessPolicy = new SharedAccessSignatureAuthorizationRuleAccessRightsDescription()
{
KeyName = this.KeyName,
Rights = string.Join(", ", accessRights.ToArray())
};
ProvisioningServiceDescription provisioningServiceDescription = GetIotDpsResource(this.ResourceGroupName, this.Name);
IList <SharedAccessSignatureAuthorizationRuleAccessRightsDescription> iotDpsAccessPolicyList = GetIotDpsAccessPolicy(this.ResourceGroupName, this.Name);
iotDpsAccessPolicyList.Add(iotDpsAccessPolicy);
provisioningServiceDescription.Properties.AuthorizationPolicies = iotDpsAccessPolicyList;
IotDpsCreateOrUpdate(this.ResourceGroupName, this.Name, provisioningServiceDescription);
iotDpsAccessPolicyList = GetIotDpsAccessPolicy(this.ResourceGroupName, this.Name);
if (iotDpsAccessPolicyList.Count == 1)
{
this.WritePSObject(iotDpsAccessPolicyList[0]);
}
else
{
this.WritePSObjects(iotDpsAccessPolicyList);
}
}
private void UpdateIotDps()
{
ProvisioningServiceDescription updatedProvisioningServiceDescription = new ProvisioningServiceDescription();
if (this.Reset.IsPresent)
{
updatedProvisioningServiceDescription = this.IotDpsClient.IotDpsResource.Update(this.ResourceGroupName, this.Name, IotDpsUtils.ToTagsResource(this.Tag.Cast <DictionaryEntry>().ToDictionary(kvp => (string)kvp.Key, kvp => (string)kvp.Value)));
}
else
{
ProvisioningServiceDescription provisioningServiceDescription = GetIotDpsResource(this.ResourceGroupName, this.Name);
foreach (var tag in provisioningServiceDescription.Tags)
{
if (!this.Tag.ContainsKey(tag.Key))
{
this.Tag.Add(tag.Key, tag.Value);
}
}
updatedProvisioningServiceDescription = this.IotDpsClient.IotDpsResource.Update(this.ResourceGroupName, this.Name, IotDpsUtils.ToTagsResource(this.Tag.Cast <DictionaryEntry>().ToDictionary(kvp => (string)kvp.Key, kvp => (string)kvp.Value)));
}
this.WritePSObject(updatedProvisioningServiceDescription);
}
public async Task UpdateSku()
{
using var context = MockContext.Start(GetType());
Initialize(context);
const string testName = "unitTestingDPSUpdateSku";
ResourceGroup rg = await GetResourceGroupAsync(testName).ConfigureAwait(false);
ProvisioningServiceDescription service = await GetServiceAsync(testName, testName).ConfigureAwait(false);
// update capacity
service.Sku.Capacity += 1;
var attempts = Constants.ArmAttemptLimit;
while (attempts > 0)
{
try
{
ProvisioningServiceDescription updatedInstance = await _provisioningClient
.IotDpsResource.CreateOrUpdateAsync(
rg.Name,
service.Name,
service)
.ConfigureAwait(false);
updatedInstance.Sku.Capacity.Should().Be(service.Sku.Capacity);
break;
}
catch
{
// Let ARM finish
await Task.Delay(Constants.ArmAttemptWaitMs).ConfigureAwait(false);
attempts--;
}
}
}
private void WritePSObject(ProvisioningServiceDescription provisioningServiceDescription)
{
this.WriteObject(IotDpsUtils.ToPSProvisioningServiceDescription(provisioningServiceDescription), false);
}
/// <summary>
/// Create or update the metadata of the provisioning service.
/// </summary>
/// <remarks>
/// Create or update the metadata of the provisioning service. The usual
/// pattern to modify a property is to retrieve the provisioning service
/// metadata and security metadata, and then combine them with the modified
/// values in a new body to update the provisioning service.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Resource group identifier.
/// </param>
/// <param name='provisioningServiceName'>
/// Name of provisioning service to create or update.
/// </param>
/// <param name='iotDpsDescription'>
/// Description of the provisioning service to create or update.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <ProvisioningServiceDescription> BeginCreateOrUpdateAsync(this IIotDpsResourceOperations operations, string resourceGroupName, string provisioningServiceName, ProvisioningServiceDescription iotDpsDescription, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, provisioningServiceName, iotDpsDescription, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public void CreateAndDelete()
{
using (var context = MockContext.Start(this.GetType().FullName))
{
this.Initialize(context);
var testName = "unitTestingDPSCreateUpdate";
this.GetResourceGroup(testName);
var availabilityInfo =
this.provisioningClient.IotDpsResource.CheckProvisioningServiceNameAvailability(new OperationInputs(testName));
if (!availabilityInfo.NameAvailable ?? false)
{
//it exists, so test the delete
this.provisioningClient.IotDpsResource.Delete(testName, testName);
//check the name is now available
availabilityInfo =
this.provisioningClient.IotDpsResource.CheckProvisioningServiceNameAvailability(new OperationInputs(testName));
Assert.True(availabilityInfo.NameAvailable);
}
//try to create a DPS service
var createServiceDescription = new ProvisioningServiceDescription(Constants.DefaultLocation,
new IotDpsPropertiesDescription(),
new IotDpsSkuInfo(Constants.DefaultSku.Name,
Constants.DefaultSku.Tier,
Constants.DefaultSku.Capacity
));
var dpsInstance = this.provisioningClient.IotDpsResource.CreateOrUpdate(
testName,
testName,
createServiceDescription);
Assert.NotNull(dpsInstance);
Assert.Equal(Constants.DefaultSku.Name, dpsInstance.Sku.Name);
Assert.Equal(testName, dpsInstance.Name);
//verify item exists in list by resource group
var existingServices =
this.provisioningClient.IotDpsResource.ListByResourceGroup(testName);
Assert.Contains(existingServices, x => x.Name == testName);
//verify can find
var foundInstance = this.provisioningClient.IotDpsResource.Get(testName, testName);
Assert.NotNull(foundInstance);
Assert.Equal(testName, foundInstance.Name);
var attempts = Constants.ArmAttemptLimit;
var success = false;
while (attempts > 0 && !success)
{
try
{
this.provisioningClient.IotDpsResource.Delete(testName, testName);
success = true;
}
catch
{
attempts--;
System.Threading.Thread.Sleep(Constants.ArmAttemptWaitMS);
}
}
existingServices =
this.provisioningClient.IotDpsResource.ListByResourceGroup(testName);
//As long as it is gone or deleting, we're good
Assert.DoesNotContain(existingServices, x => x.Name == testName && x.Properties.State != "Deleting");
}
}
/// <summary>
/// Create or update the metadata of the provisioning service.
/// </summary>
/// <remarks>
/// Create or update the metadata of the provisioning service. The usual
/// pattern to modify a property is to retrieve the provisioning service
/// metadata and security metadata, and then combine them with the modified
/// values in a new body to update the provisioning service.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Resource group identifier.
/// </param>
/// <param name='provisioningServiceName'>
/// Name of provisioning service to create or update.
/// </param>
/// <param name='iotDpsDescription'>
/// Description of the provisioning service to create or update.
/// </param>
public static ProvisioningServiceDescription CreateOrUpdate(this IIotDpsResourceOperations operations, string resourceGroupName, string provisioningServiceName, ProvisioningServiceDescription iotDpsDescription)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, provisioningServiceName, iotDpsDescription).GetAwaiter().GetResult());
}
public ProvisioningServiceDescription IotDpsCreateOrUpdate(string resourceGroupName, string provisioningServiceName, ProvisioningServiceDescription provisioningServiceDescription)
{
return(this.IotDpsClient.IotDpsResource.CreateOrUpdate(resourceGroupName, provisioningServiceName, provisioningServiceDescription));
}
public IList <IotHubDefinitionDescription> GetIotDpsHubs(string resourceGroupName, string provisioningServiceName)
{
ProvisioningServiceDescription provisioningServiceDescription = this.GetIotDpsResource(resourceGroupName, provisioningServiceName);
return(provisioningServiceDescription.Properties.IotHubs);
}
public static PSProvisioningServiceDescription ToPSProvisioningServiceDescription(ProvisioningServiceDescription provisioningServiceDescription)
{
return(ConvertObject <ProvisioningServiceDescription, PSProvisioningServiceDescription>(provisioningServiceDescription));
}
public async Task CreateAndDelete()
{
using var context = MockContext.Start(GetType());
var testName = "unitTestingDPSLinkedHubCreateUpdateDelete";
Initialize(context);
var iotHubClient = GetClient <IotHubClient>(context);
ResourceGroup resourceGroup = await GetResourceGroupAsync(testName).ConfigureAwait(false);
ProvisioningServiceDescription testedService = await GetServiceAsync(resourceGroup.Name, testName).ConfigureAwait(false);
IotHubDescription iotHub = await GetIotHubAsync(iotHubClient, resourceGroup, testName).ConfigureAwait(false);
IPage <SharedAccessSignatureAuthorizationRule> keys = await iotHubClient.IotHubResource
.ListKeysAsync(
resourceGroup.Name,
iotHub.Name)
.ConfigureAwait(false);
SharedAccessSignatureAuthorizationRule key = keys.FirstOrDefault(x => x.Rights.HasFlag(AccessRights.ServiceConnect));
var connectionString = $"HostName={iotHub.Name}.azure-devices.net;SharedAccessKeyName={key.KeyName};SharedAccessKey={key.PrimaryKey}";
testedService.Properties.IotHubs = testedService.Properties.IotHubs ?? new List <IotHubDefinitionDescription>(1);
testedService.Properties.IotHubs.Add(new IotHubDefinitionDescription(connectionString, resourceGroup.Location, name: testName));
ProvisioningServiceDescription updatedInstance = await _provisioningClient.IotDpsResource
.CreateOrUpdateAsync(
resourceGroup.Name,
testName,
testedService)
.ConfigureAwait(false);
IotHubDefinitionDescription returnedHub = updatedInstance.Properties.IotHubs
.FirstOrDefault(x => x.Name.Equals($"{iotHub.Name}.azure-devices.net"));
returnedHub.Should().NotBeNull();
connectionString = returnedHub.ConnectionString;
bool hasUpdatedApplyPolicy = !(returnedHub.ApplyAllocationPolicy ?? false);
returnedHub.ApplyAllocationPolicy = hasUpdatedApplyPolicy;
int updatedPolicyWeight = Helpers.Constants.RandomAllocationWeight;
returnedHub.AllocationWeight = updatedPolicyWeight;
updatedInstance = await _provisioningClient.IotDpsResource
.CreateOrUpdateAsync(
resourceGroup.Name,
testName,
updatedInstance)
.ConfigureAwait(false);
IotHubDefinitionDescription updatedHub = updatedInstance.Properties.IotHubs
.FirstOrDefault(x => x.ConnectionString == connectionString);
updatedHub.Should().NotBeNull();
updatedHub.ApplyAllocationPolicy.Should().Be(hasUpdatedApplyPolicy);
updatedHub.AllocationWeight.Should().Be(updatedPolicyWeight);
// Delete the linked hub
testedService.Properties.IotHubs = testedService.Properties.IotHubs
.Except(testedService.Properties.IotHubs.Where(x => x.Name == testName))
.ToList();
updatedInstance = await _provisioningClient.IotDpsResource
.CreateOrUpdateAsync(
resourceGroup.Name,
testName,
testedService)
.ConfigureAwait(false);
updatedInstance.Properties.IotHubs.Should().NotContain(connectionString);
}
public async Task CreateAndDeleteDataResidency()
{
using var context = MockContext.Start(GetType());
Initialize(context);
const string testName = "unitTestingDPSCreateDataResidency";
ResourceGroup rg = await GetResourceGroupAsync(testName);
var availabilityInfo = await _provisioningClient.IotDpsResource
.CheckProvisioningServiceNameAvailabilityAsync(testName)
.ConfigureAwait(false);
if (availabilityInfo.NameAvailable.HasValue && !availabilityInfo.NameAvailable.Value)
{
// it exists, so test the delete
await _provisioningClient.IotDpsResource
.DeleteAsync(testName, rg.Name)
.ConfigureAwait(false);
// check the name is now available
availabilityInfo = await _provisioningClient.IotDpsResource
.CheckProvisioningServiceNameAvailabilityAsync(testName)
.ConfigureAwait(false);
availabilityInfo.NameAvailable.Should().BeTrue();
}
// try to create a DPS service
var createServiceDescription = new ProvisioningServiceDescription(
"BrazilSouth",
new IotDpsPropertiesDescription(enableDataResidency: true),
new IotDpsSkuInfo(
Constants.DefaultSku.Name,
Constants.DefaultSku.Tier,
Constants.DefaultSku.Capacity));
var dpsInstance = await _provisioningClient.IotDpsResource
.CreateOrUpdateAsync(
rg.Name,
testName,
createServiceDescription)
.ConfigureAwait(false);
dpsInstance.Should().NotBeNull();
dpsInstance.Sku.Name.Should().Be(Constants.DefaultSku.Name);
dpsInstance.Name.Should().Be(testName);
// verify item exists in list by resource group
IPage <ProvisioningServiceDescription> existingServices = await _provisioningClient.IotDpsResource
.ListByResourceGroupAsync(rg.Name)
.ConfigureAwait(false);
existingServices.Should().Contain(x => x.Name == testName);
// verify can find
ProvisioningServiceDescription foundInstance = await _provisioningClient.IotDpsResource
.GetAsync(testName, testName)
.ConfigureAwait(false);
foundInstance.Should().NotBeNull();
foundInstance.Name.Should().Be(testName);
var attempts = Constants.ArmAttemptLimit;
while (attempts > 0)
{
try
{
await _provisioningClient.IotDpsResource
.DeleteAsync(testName, rg.Name)
.ConfigureAwait(false);
break;
}
catch
{
attempts--;
await Task.Delay(Constants.ArmAttemptWaitMs).ConfigureAwait(false);
}
}
existingServices = await _provisioningClient.IotDpsResource
.ListByResourceGroupAsync(testName)
.ConfigureAwait(false);
// As long as it is gone or deleting, we're good
existingServices.Should().NotContain(x => x.Name == testName && x.Properties.State != "Deleting");
}
public async Task ListCreateDelete()
{
using var context = MockContext.Start(GetType());
Initialize(context);
var testName = "unitTestingDPSSharedAccessPoliciesListCreateDelete";
ResourceGroup resourceGroup = await GetResourceGroupAsync(testName).ConfigureAwait(false);
ProvisioningServiceDescription testedService = await GetServiceAsync(testName, testName).ConfigureAwait(false);
// verify owner has been created
var ownerKey = await _provisioningClient.IotDpsResource
.ListKeysForKeyNameAsync(
testedService.Name,
Constants.AccessKeyName,
resourceGroup.Name)
.ConfigureAwait(false);
ownerKey.KeyName.Should().Be(Constants.AccessKeyName);
// this access policy should not exist
var keyInfo = await TryGetKeyByNameAsync(testName).ConfigureAwait(false);
keyInfo.hasKey.Should().BeFalse();
keyInfo.accessPolicy.Should().BeNull();
// new key
testedService.Properties.AuthorizationPolicies =
new List <SharedAccessSignatureAuthorizationRuleAccessRightsDescription>(
new[]
{
ownerKey,
new SharedAccessSignatureAuthorizationRuleAccessRightsDescription(
testName,
rights: "RegistrationStatusWrite"),
});
var attempts = Constants.ArmAttemptLimit;
while (attempts > 0)
{
try
{
await _provisioningClient.IotDpsResource
.CreateOrUpdateAsync(testName, testedService.Name, testedService)
.ConfigureAwait(false);
break;
}
catch
{
// Let ARM finish
await Task.Delay(Constants.ArmAttemptWaitMs).ConfigureAwait(false);
attempts--;
}
}
// this access policy exists now
keyInfo = await TryGetKeyByNameAsync(testName).ConfigureAwait(false);
keyInfo.hasKey.Should().BeTrue();
keyInfo.accessPolicy.Should().NotBeNull();
testedService.Properties.AuthorizationPolicies =
new List <SharedAccessSignatureAuthorizationRuleAccessRightsDescription>(
new[]
{
ownerKey,
});
attempts = Constants.ArmAttemptLimit;
while (attempts > 0)
{
try
{
await _provisioningClient.IotDpsResource
.CreateOrUpdateAsync(testName, testedService.Name, testedService)
.ConfigureAwait(false);
break;
}
catch
{
// Let ARM finish
await Task.Delay(Constants.ArmAttemptWaitMs).ConfigureAwait(false);
attempts--;
}
}
// the policy has been removed
keyInfo = await TryGetKeyByNameAsync(testName).ConfigureAwait(false);
keyInfo.hasKey.Should().BeFalse();
keyInfo.accessPolicy.Should().BeNull();
}
