Device Provisioning Service

src/SDKs/DeviceProvisioningServices/AzSdk.RP.props

@@ -0,0 +1,7 @@
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--This file and it's contents are updated at build time moving or editing might result in build failure. Take due deligence while editing this file-->
+  <PropertyGroup>
+    <AzureApiTag>Devices_2017-11-15;</AzureApiTag>
+    <PackageTags>$(PackageTags);$(CommonTags);$(AzureApiTag);</PackageTags>
+  </PropertyGroup>
+</Project>

src/SDKs/DeviceProvisioningServices/DeviceProvisioningServices.Tests/DeviceProvisioningServices.Tests.csproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('AzSdk.test.reference.props'))" />
+  <PropertyGroup>
+    <PackageId>DeviceProvisioningServices.Tests</PackageId>
+    <Description>DeviceProvisioningServices.Tests Class Library</Description>
+    <AssemblyName>DeviceProvisioningServices.Tests</AssemblyName>
+    <VersionPrefix>1.0.1-preview</VersionPrefix>    
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <TargetFrameworks>netcoreapp1.1</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Management.EventHub" Version="2.0.2" />
+    <PackageReference Include="Microsoft.Azure.Management.ServiceBus" Version="0.2.0-preview" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\IotHub\Management.IotHub\Microsoft.Azure.Management.IotHub.csproj" />
+    <ProjectReference Include="..\Management.DeviceProvisioningServices\Microsoft.Azure.Management.DeviceProvisioningServices.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="SessionRecords\**\*.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <!--Do not remove until VS Test Tools fixes #472-->
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+</Project>

src/SDKs/DeviceProvisioningServices/DeviceProvisioningServices.Tests/Helpers/Constants.cs

@@ -0,0 +1,41 @@
+namespace DeviceProvisioningServices.Tests.Helpers
+{
+    public static class Constants
+    {
+        public const string AccessKeyName = "provisioningserviceowner";
+
+        public static class Certificate
+        {
+            public const string Content =
+                "MIIBvjCCAWOgAwIBAgIQG6PoBFT6GLJGNKn/EaxltTAKBggqhkjOPQQDAjAcMRow"
+                + "GAYDVQQDDBFBenVyZSBJb1QgUm9vdCBDQTAeFw0xNzExMDMyMDUyNDZaFw0xNzEy"
+                + "MDMyMTAyNDdaMBwxGjAYBgNVBAMMEUF6dXJlIElvVCBSb290IENBMFkwEwYHKoZI"
+                + "zj0CAQYIKoZIzj0DAQcDQgAE+CgpnW3K+KRNIi/U6Zqe/Al9m8PExHX2KgakmGTf"
+                + "E04nNBwnSoygWb0ekqpT+Lm+OP56LMMe9ynVNryDEr9OSKOBhjCBgzAOBgNVHQ8B"
+                + "Af8EBAMCAgQwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMB8GA1UdEQQY"
+                + "MBaCFENOPUF6dXJlIElvVCBSb290IENBMBIGA1UdEwEB/wQIMAYBAf8CAQwwHQYD"
+                + "VR0OBBYEFDjiklfHQzw1G0A33BcmRQTjAivTMAoGCCqGSM49BAMCA0kAMEYCIQCt"
+                + "jJ4bAvoYuDhwr92Kk+OkvpPF+qBFiRfrA/EC4YGtzQIhAO79WPtbUnBQ5fsQnW2a"
+                + "UAT4yJGWL+7l4/qfmqblb96n";
+
+            public const string Name = "DPStestCert";
+            public const string Subject = "CN=Azure IoT Root CA";
+            public const string Thumbprint = "9F0983E8F2DB2DB3582997FEF331247D872DEE32";
+        }
+
+        public const string DefaultLocation = "eastus";
+
+        public static class DefaultSku
+        {
+            public const string Name = "S1";
+            public const int Capacity = 1;
+            public const string Tier = "S1";
+        }
+
+        public static readonly string[] AllocationPolicies = {"Hashed", "GeoLatency", "Static"};
+
+        public const int ArmAttemptWaitMS = 500;
+        public const int RandomAllocationWeight = 870084357;
+        public const int ArmAttemptLimit = 5;
+    }
+}

src/SDKs/DeviceProvisioningServices/DeviceProvisioningServices.Tests/Helpers/RecordedDelegatingHandler.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+
+namespace DeviceProvisioningServices.Tests.Helpers
+{
+    public class RecordedDelegatingHandler : DelegatingHandler
+    {
+        private HttpResponseMessage _response;
+
+        public RecordedDelegatingHandler()
+        {
+            StatusCodeToReturn = HttpStatusCode.Created;
+            SubsequentStatusCodeToReturn = StatusCodeToReturn;
+        }
+
+        public RecordedDelegatingHandler(HttpResponseMessage response)
+        {
+            StatusCodeToReturn = HttpStatusCode.Created;
+            SubsequentStatusCodeToReturn = StatusCodeToReturn;
+            _response = response;
+        }
+
+        public HttpStatusCode StatusCodeToReturn { get; set; }
+
+        public HttpStatusCode SubsequentStatusCodeToReturn { get; set; }
+
+        public string Request { get; private set; }
+
+        public HttpRequestHeaders RequestHeaders { get; private set; }
+
+        public HttpContentHeaders ContentHeaders { get; private set; }
+
+        public HttpMethod Method { get; private set; }
+
+        public Uri Uri { get; private set; }
+
+        public bool IsPassThrough { get; set; }
+
+        private int counter;
+
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
+        {
+            counter++;
+            // Save request
+            if (request.Content == null)
+            {
+                Request = string.Empty;
+            }
+            else
+            {
+                Request = await request.Content.ReadAsStringAsync();
+            }
+            RequestHeaders = request.Headers;
+            if (request.Content != null)
+            {
+                ContentHeaders = request.Content.Headers;
+            }
+            Method = request.Method;
+            Uri = request.RequestUri;
+
+            // Prepare response
+            if (IsPassThrough)
+            {
+                return await base.SendAsync(request, cancellationToken);
+            }
+            else
+            {
+                if (_response != null && counter == 1)
+                {
+                    return _response;
+                }
+                else
+                {
+                    var statusCode = StatusCodeToReturn;
+                    if (counter > 1)
+                        statusCode = SubsequentStatusCodeToReturn;
+                    HttpResponseMessage response = new HttpResponseMessage(statusCode);
+                    response.Content = new StringContent("");
+                    return response;
+                }
+            }
+        }
+    }
+}

src/SDKs/DeviceProvisioningServices/DeviceProvisioningServices.Tests/ScenarioTests/DeviceProvisioningClientAllocationPolicyTests.cs

@@ -0,0 +1,64 @@
+using System.Linq;
+using DeviceProvisioningServices.Tests.Helpers;
+using Microsoft.Azure.Management.DeviceProvisioningServices;
+using Microsoft.Rest.ClientRuntime.Azure.TestFramework;
+using Xunit;
+
+namespace DeviceProvisioningServices.Tests.ScenarioTests
+{
+    public class DeviceProvisioningClientAllocationPolicyTests : DeviceProvisioningTestBase
+    {
+        [Fact]
+        public void Get()
+        {
+            using (var context = MockContext.Start(this.GetType().FullName))
+            {
+                var testName = "unitTestingUpdateAllocationPolicyGet";
+                this.Initialize(context);
+                var resourceGroup = this.GetResourceGroup(testName);
+                var testedService = GetService(testName, resourceGroup.Name);
+
+
+                Assert.Contains(Constants.AllocationPolicies, x => x.Equals(testedService.Properties.AllocationPolicy));
+            }
+        }
+        [Fact]
+        public void Update()
+        {
+            using (var context = MockContext.Start(this.GetType().FullName))
+            {
+                var testName = "unitTestingDPSAllocationPolicyUpdate";
+                this.Initialize(context);
+                var resourceGroup = this.GetResourceGroup(testName);
+                var testedService = GetService(testName, testName);
+
+                //get a different Allocation policy
+                var newAllocationPolicy = Constants.AllocationPolicies
+                    .Except(new[] { testedService.Properties.AllocationPolicy }).First();
+
+                var attempts = Constants.ArmAttemptLimit;
+                while (attempts > 0 && testedService.Properties.AllocationPolicy != newAllocationPolicy)
+                {
+                    testedService.Properties.AllocationPolicy = newAllocationPolicy;
+                    try
+                    {
+                        var updatedInstance =
+                            this.provisioningClient.IotDpsResource.CreateOrUpdate(resourceGroup.Name, testName,
+                                testedService);
+                        Assert.Equal(newAllocationPolicy, updatedInstance.Properties.AllocationPolicy);
+
+                        testedService.Properties.AllocationPolicy = updatedInstance.Properties.AllocationPolicy;
+                    }
+                    catch
+                    {
+                        //Let ARM finish
+                        System.Threading.Thread.Sleep(Constants.ArmAttemptWaitMS);
+
+                        attempts--;
+                    }
+                }
+            }
+        }
+
+    }
+}

src/SDKs/DeviceProvisioningServices/DeviceProvisioningServices.Tests/ScenarioTests/DeviceProvisioningClientCertificates.cs

@@ -0,0 +1,55 @@
+using System.Linq;
+using Microsoft.Azure.Management.DeviceProvisioningServices;
+using Microsoft.Azure.Management.DeviceProvisioningServices.Models;
+using Microsoft.Rest.ClientRuntime.Azure.TestFramework;
+using DeviceProvisioningServices.Tests.Helpers;
+using Xunit;
+
+namespace DeviceProvisioningServices.Tests.ScenarioTests
+{
+    public class DeviceProvisioningClientCertificates : DeviceProvisioningTestBase
+    {
+
+        [Fact]
+        public void CreateAndDelete()
+        {
+            using (var context = MockContext.Start(this.GetType().FullName))
+            {
+                this.Initialize(context);
+                var testName = "unitTestingDPSCertificatesCreateAndDelete";
+                var resourceGroup = this.GetResourceGroup(testName);
+                var service = this.GetService(resourceGroup.Name, testName);
+
+                //add a cert
+                this.provisioningClient.DpsCertificate.CreateOrUpdate(testName,
+                    testName, Constants.Certificate.Name,
+                    new CertificateBodyDescription(Constants.Certificate.Content));
+
+                var certificateList = this.provisioningClient.DpsCertificates.List(testName,
+                    testName);
+
+                Assert.Contains(certificateList.Value, x => x.Name == Constants.Certificate.Name);
+
+                //verify certificate details
+                var certificateDetails =
+                    certificateList.Value.FirstOrDefault(x => x.Name == Constants.Certificate.Name);
+                Assert.NotNull(certificateDetails);
+                Assert.Equal(certificateDetails.Properties.Subject, Constants.Certificate.Subject);
+                Assert.Equal(certificateDetails.Properties.Thumbprint, Constants.Certificate.Thumbprint);
+
+                //can get a verification code
+                var verificationCodeResponse =
+                    this.provisioningClient.DpsCertificate.GenerateVerificationCode(certificateDetails.Name,
+                        certificateDetails.Etag, resourceGroup.Name, service.Name);
+                Assert.NotNull(verificationCodeResponse.Properties);
+                Assert.False(string.IsNullOrEmpty(verificationCodeResponse.Properties.VerificationCode));
+
+                //delete certificate
+                this.provisioningClient.DpsCertificate.Delete(resourceGroup.Name, verificationCodeResponse.Etag, service.Name, Constants.Certificate.Name);
+                certificateList = this.provisioningClient.DpsCertificates.List(testName,
+                    testName);
+                Assert.DoesNotContain(certificateList.Value, x => x.Name == Constants.Certificate.Name);
+            }
+        }
+    }
+}

src/SDKs/DeviceProvisioningServices/DeviceProvisioningServices.Tests/ScenarioTests/DeviceProvisioningClientLinkedHubsTests.cs

@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Azure.Management.IotHub;
+using Microsoft.Azure.Management.IotHub.Models;
+using Microsoft.Azure.Management.DeviceProvisioningServices;
+using Microsoft.Azure.Management.DeviceProvisioningServices.Models;
+using Microsoft.Azure.Management.Resources.Models;
+using Microsoft.Rest.ClientRuntime.Azure.TestFramework;
+using Xunit;
+
+namespace DeviceProvisioningServices.Tests.ScenarioTests
+{
+    public class DeviceProvisioningClientLinkedHubsTests : DeviceProvisioningTestBase
+    {
+        [Fact]
+        public void CreateAndDelete()
+        {
+            using (var context = MockContext.Start(this.GetType().FullName))
+            {
+                var testName = "unitTestingDPSLinkedHubCreateUpdateDelete";
+                this.Initialize(context);
+                var iotHubClient = this.GetClient<IotHubClient>(context);
+                var resourceGroup = this.GetResourceGroup(testName);
+                var testedService = GetService(testName, resourceGroup.Name);
+
+                var iotHub = GetIoTHub(iotHubClient, resourceGroup, testName);
+                var keys = iotHubClient.IotHubResource.ListKeys(
+                    resourceGroup.Name,
+                    iotHub.Name);
+                var 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));
+                var updatedInstance = 
+                    this.provisioningClient.IotDpsResource.CreateOrUpdate(resourceGroup.Name, testName,
+                    testedService);
+
+                var returnedHub = updatedInstance.Properties.IotHubs.FirstOrDefault(x => x.ConnectionString.StartsWith($"HostName={iotHub.Name}.azure-devices.net;"));
+                Assert.NotNull(returnedHub);
+                connectionString = returnedHub.ConnectionString;
+
+                var updatedApplyPolicy = !(returnedHub.ApplyAllocationPolicy ?? false);
+                returnedHub.ApplyAllocationPolicy = updatedApplyPolicy;
+
+                var updatedPolicyWeight = Helpers.Constants.RandomAllocationWeight;
+                returnedHub.AllocationWeight = updatedPolicyWeight;
+
+                updatedInstance =
+                    this.provisioningClient.IotDpsResource.CreateOrUpdate(resourceGroup.Name, testName,
+                        updatedInstance);
+                var updatedHub = updatedInstance.Properties.IotHubs.FirstOrDefault(x => x.ConnectionString == connectionString);
+                Assert.NotNull(updatedHub);
+
+                Assert.Equal(updatedApplyPolicy, updatedHub.ApplyAllocationPolicy);
+                Assert.Equal(updatedPolicyWeight, updatedHub.AllocationWeight);
+
+
+                //Delete the linked hub
+                testedService.Properties.IotHubs = testedService.Properties.IotHubs.Except(
+                    testedService.Properties.IotHubs.Where(x => x.Name == testName)).ToList();
+                updatedInstance = this.provisioningClient.IotDpsResource.CreateOrUpdate(resourceGroup.Name, testName,
+                    testedService);
+                Assert.DoesNotContain(updatedInstance.Properties.IotHubs, x=> x.ConnectionString == connectionString);
+
+            }
+        }
+
+
+        private IotHubDescription GetIoTHub(IotHubClient iotHubClient, ResourceGroup resourceGroup, string hubName)
+        {
+            return iotHubClient.IotHubResource.CreateOrUpdate(
+                resourceGroup.Name,
+                hubName,
+            new IotHubDescription
+            {
+                Location = resourceGroup.Location,
+                Subscriptionid = testEnv.SubscriptionId,
+                Resourcegroup = resourceGroup.Name,
+                Sku = new IotHubSkuInfo
+                {
+                    Name = "S1",
+                    Capacity = 1
+                },
+                Properties = new IotHubProperties
+                {
+                    Routing = new RoutingProperties()
+                }
+            });
+        }
+    }
+}