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(); }