public void IotHubConnectionStringBuilder_ParamHostNameAuthMethod_SharedAccessKey()
        {
            var authMethod = new DeviceAuthenticationWithSharedAccessPolicyKey(DeviceId, SharedAccessKeyName, SharedAccessKey);
            var csBuilder  = IotHubConnectionStringBuilder.Create(HostName, authMethod);

            csBuilder.HostName.Should().Be(HostName);
            csBuilder.DeviceId.Should().Be(DeviceId);
            csBuilder.SharedAccessKey.Should().Be(SharedAccessKey);
            csBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithSharedAccessPolicyKey>();

            csBuilder.SharedAccessSignature.Should().BeNull();
        }
        public void DeviceClientIotHubConnectionStringBuilderTest()
        {
            string connectionString = "HostName=acme.azure-devices.net;SharedAccessKeyName=AllAccessKey;DeviceId=device1;SharedAccessKey=dGVzdFN0cmluZzE=";
            var    iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);

            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);

            connectionString = "HostName=acme.azure-devices.net;GatewayHostName=test;SharedAccessKeyName=AllAccessKey;DeviceId=device1;SharedAccessKey=dGVzdFN0cmluZzE=";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNotNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);

            connectionString = "HostName=acme.azure-devices.net;CredentialType=SharedAccessSignature;DeviceId=device1;SharedAccessSignature=SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);

            connectionString = "HostName=acme.azure-devices.net;CredentialScope=Device;DeviceId=device1;SharedAccessKey=dGVzdFN0cmluZzE=";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);

            connectionString = "HostName=acme.azure-devices.net;CredentialScope=Device;DeviceId=device1;SharedAccessSignature=SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);

            try
            {
                iotHubConnectionStringBuilder.HostName = "adshgfvyregferuehfiuehr";
                Assert.Fail("Expected FormatException");
            }
            catch (FormatException)
            {
            }

            iotHubConnectionStringBuilder.HostName             = "acme.azure-devices.net";
            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "dGVzdFN0cmluZzE=");
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "dGVzdFN0cmluZzE=");
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device1");

            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken("Device2", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device2");

            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithSharedAccessPolicyKey("Device3", "AllAccess", "dGVzdFN0cmluZzI=");
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "dGVzdFN0cmluZzI=");
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device3");

            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken("Device4", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device4");

            IAuthenticationMethod authMethod = AuthenticationMethodFactory.CreateAuthenticationWithToken("Device5", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");

            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme1.azure-devices.net", authMethod);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
            Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme1.azure-devices.net");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device5");

            authMethod = new DeviceAuthenticationWithSharedAccessPolicyKey("Device3", "AllAccess", "dGVzdFN0cmluZzI=");
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme2.azure-devices.net", authMethod);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
            Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme2.azure-devices.net");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "dGVzdFN0cmluZzI=");
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device3");

            authMethod = new DeviceAuthenticationWithToken("Device2", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme3.azure-devices.net", authMethod);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
            Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme3.azure-devices.net");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device2");

            authMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "dGVzdFN0cmluZzE=");
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme4.azure-devices.net", authMethod);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
            Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme4.azure-devices.net");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "dGVzdFN0cmluZzE=");
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device1");

            string hostName        = "acme.azure-devices.net";
            string gatewayHostname = "gateway.acme.azure-devices.net";
            IAuthenticationMethod authenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "dGVzdFN0cmluZzE=");

            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, gatewayHostname, authenticationMethod);
            Assert.AreEqual(gatewayHostname, iotHubConnectionStringBuilder.GatewayHostName);
            Assert.AreEqual(hostName, iotHubConnectionStringBuilder.HostName);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);

            hostName                      = "acme.azure-devices.net";
            authenticationMethod          = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "dGVzdFN0cmluZzE=");
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authenticationMethod);
            Assert.AreEqual(hostName, iotHubConnectionStringBuilder.HostName);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
            Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
        }
        public void DeviceClientIotHubConnectionStringBuilderTest()
        {
            string connectionString = "HostName=acme.azure-devices.net;SharedAccessKeyName=AllAccessKey;DeviceId=device1;SharedAccessKey=CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=";
            var    iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);

            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);

            connectionString = "HostName=acme.azure-devices.net;GatewayHostName=test;SharedAccessKeyName=AllAccessKey;DeviceId=device1;SharedAccessKey=CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNotNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);

            connectionString = "HostName=acme.azure-devices.net;CredentialType=SharedAccessSignature;DeviceId=device1;SharedAccessSignature=SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);

            connectionString = "HostName=acme.azure-devices.net;CredentialScope=Device;DeviceId=device1;SharedAccessKey=CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);

            connectionString = "HostName=acme.azure-devices.net;CredentialScope=Device;DeviceId=device1;SharedAccessSignature=SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            Assert.IsNotNull(iotHubConnectionStringBuilder.HostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.DeviceId);
            Assert.IsNull(iotHubConnectionStringBuilder.GatewayHostName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.AuthenticationMethod);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKey);
            Assert.IsNull(iotHubConnectionStringBuilder.SharedAccessKeyName);
            Assert.IsNotNull(iotHubConnectionStringBuilder.SharedAccessSignature);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);

            try
            {
                iotHubConnectionStringBuilder.HostName = "adshgfvyregferuehfiuehr";
                Assert.Fail("Expected FormatException");
            }
            catch (FormatException)
            {
            }

            iotHubConnectionStringBuilder.HostName             = "acme.azure-devices.net";
            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device1");

            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken("Device2", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device2");

            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithSharedAccessPolicyKey("Device3", "AllAccess", "KQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "KQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device3");

            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken("Device4", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device4");

            IAuthenticationMethod authMethod = AuthenticationMethodFactory.CreateAuthenticationWithToken("Device5", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");

            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme1.azure-devices.net", authMethod);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
            Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme1.azure-devices.net");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device5");

            authMethod = new DeviceAuthenticationWithSharedAccessPolicyKey("Device3", "AllAccess", "KQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme2.azure-devices.net", authMethod);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithSharedAccessPolicyKey);
            Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme2.azure-devices.net");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "KQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device3");

            authMethod = new DeviceAuthenticationWithToken("Device2", "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme3.azure-devices.net", authMethod);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithToken);
            Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme3.azure-devices.net");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=poifbMLdBGtCJknubF2FW6FLn5vND5k1IKoeQ%2bONgkE%3d&se=87824124985&skn=AllAccessKey");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device2");

            authMethod = new DeviceAuthenticationWithRegistrySymmetricKey("Device1", "CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create("acme4.azure-devices.net", authMethod);
            Assert.IsTrue(iotHubConnectionStringBuilder.AuthenticationMethod is DeviceAuthenticationWithRegistrySymmetricKey);
            Assert.IsTrue(iotHubConnectionStringBuilder.HostName == "acme4.azure-devices.net");
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessSignature == null);
            Assert.IsTrue(iotHubConnectionStringBuilder.SharedAccessKey == "CQN2K33r45/0WeIjpqmErV5EIvX8JZrozt3NEHCEkG8=");
            Assert.IsTrue(iotHubConnectionStringBuilder.DeviceId == "Device1");
        }
Esempio n. 4
0
        public void DeviceClientIotHubConnectionStringBuilderTest()
        {
            const string hostName                   = "acme.azure-devices.net";
            const string gatewayHostName            = "gateway.acme.azure-devices.net";
            const string transparentGatewayHostName = "test";
            const string deviceId                   = "device1";
            const string deviceIdSplChar            = "device1-.+%_#*?!(),=@;$'";
            const string sharedAccessKey            = "dGVzdFN0cmluZzE=";
            const string sharedAccessKeyName        = "AllAccessKey";
            const string credentialScope            = "Device";
            const string credentialType             = "SharedAccessSignature";
            const string sharedAccessSignature      = "SharedAccessSignature sr=dh%3a%2f%2facme.azure-devices.net&sig=dGVzdFN0cmluZzU=&se=87824124985&skn=AllAccessKey";

            string connectionString = $"HostName={hostName};SharedAccessKeyName={sharedAccessKeyName};DeviceId={deviceIdSplChar};SharedAccessKey={sharedAccessKey}";
            var    iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);

            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceIdSplChar);
            iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessKeyName.Should().Be(sharedAccessKeyName);
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithSharedAccessPolicyKey>();

            connectionString = $"HostName={hostName};GatewayHostName={transparentGatewayHostName};SharedAccessKeyName={sharedAccessKeyName};DeviceId={deviceId};SharedAccessKey={sharedAccessKey}";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.GatewayHostName.Should().Be(transparentGatewayHostName);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessKeyName.Should().Be(sharedAccessKeyName);
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithSharedAccessPolicyKey>();

            connectionString = $"HostName={hostName};CredentialType={credentialType};DeviceId={deviceId};SharedAccessSignature={sharedAccessSignature}";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();

            connectionString = $"HostName={hostName};CredentialScope={credentialScope};DeviceId={deviceId};SharedAccessKey={sharedAccessKey}";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessKeyName.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();

            connectionString = $"HostName={hostName};CredentialScope={credentialScope};DeviceId={deviceId};SharedAccessSignature={sharedAccessSignature}";
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessKeyName.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();

            iotHubConnectionStringBuilder.HostName             = transparentGatewayHostName;
            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);
            iotHubConnectionStringBuilder.HostName.Should().Be(transparentGatewayHostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceIdSplChar);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();

            iotHubConnectionStringBuilder.HostName             = hostName;
            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceIdSplChar);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();

            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken(deviceId, sharedAccessSignature);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();

            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithSharedAccessPolicyKey(deviceId, sharedAccessKeyName, sharedAccessKey);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithSharedAccessPolicyKey>();

            iotHubConnectionStringBuilder.AuthenticationMethod = new DeviceAuthenticationWithToken(deviceId, sharedAccessSignature);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();

            IAuthenticationMethod authMethod = AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sharedAccessSignature);

            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authMethod);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();

            authMethod = new DeviceAuthenticationWithSharedAccessPolicyKey(deviceId, sharedAccessKeyName, sharedAccessKey);
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authMethod);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithSharedAccessPolicyKey>();

            authMethod = new DeviceAuthenticationWithToken(deviceId, sharedAccessSignature);
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authMethod);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceId);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().Be(sharedAccessSignature);
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithToken>();

            authMethod = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authMethod);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.DeviceId.Should().Be(deviceIdSplChar);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();

            IAuthenticationMethod authenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);

            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, gatewayHostName, authenticationMethod);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.GatewayHostName.Should().Be(gatewayHostName);
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();

            authenticationMethod          = new DeviceAuthenticationWithRegistrySymmetricKey(deviceIdSplChar, sharedAccessKey);
            iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(hostName, authenticationMethod);
            iotHubConnectionStringBuilder.HostName.Should().Be(hostName);
            iotHubConnectionStringBuilder.GatewayHostName.Should().BeNull();
            iotHubConnectionStringBuilder.SharedAccessKey.Should().Be(sharedAccessKey);
            iotHubConnectionStringBuilder.SharedAccessSignature.Should().BeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().NotBeNull();
            iotHubConnectionStringBuilder.AuthenticationMethod.Should().BeOfType <DeviceAuthenticationWithRegistrySymmetricKey>();
        }
Esempio n. 5
0
        static void Main(string[] args)
        {
            Console.WriteLine("Starting to generate data. Press \'q\' to quit the Simulator.\n");

            _startTime = System.DateTime.Now;
            _sensor    = new Sensor();

            // Initialize Device Client GLOBALLY
            var devices = new Device[3];

            devices[0] = new Device {
                Id = "TestSensor1"
            };
            devices[1] = new Device {
                Id = "TestSensor2"
            };
            devices[2] = new Device {
                Id = "TestSensor3"
            };

            var deviceClients = new DeviceClient[3];

            for (int i = 0; i < 3; i++)
            {
                // Authenticate using TOKEN

                /*
                 * var auth = new DeviceAuthenticationWithToken(
                 *  devices[i].Id,
                 *  "[token]");
                 */

                // Authenticate using KEY
                var auth = new DeviceAuthenticationWithSharedAccessPolicyKey(
                    devices[i].Id,
                    "[shared access policy name]",
                    "[shared access policy key]");

                deviceClients[i] = DeviceClient.Create(
                    "[iothubname].azure-devices.net",
                    auth,
                    new ITransportSettings[]
                {
                    new AmqpTransportSettings(TransportType.Amqp_Tcp_Only)
                    {
                        AmqpConnectionPoolSettings = new AmqpConnectionPoolSettings()
                        {
                            Pooling               = true,
                            MaxPoolSize           = 1,
                            ConnectionIdleTimeout = TimeSpan.FromMilliseconds(10000)
                        }
                    }
                }
                    );

                deviceClients[i].OpenAsync();

                Console.WriteLine(devices[i].Id + ": Opening Connection");

                devices[i].DC = deviceClients[i];
            }

            // Do Sync processing.

            Thread myThread1 = new Thread(new ParameterizedThreadStart(SendMessagesSync));

            myThread1.Start(devices[0]);

            Thread myThread2 = new Thread(new ParameterizedThreadStart(SendMessagesSync));

            myThread2.Start(devices[1]);

            Thread myThread3 = new Thread(new ParameterizedThreadStart(SendMessagesSync));

            myThread3.Start(devices[2]);

            // Done.
            while (Console.Read() != 'q')
            {
                ;
            }
        }
        private async Task <DeviceClient> ResolveDeviceClient(string deviceId, string sasToken = null, DateTime?tokenExpiration = null)
        {
            try
            {
                var deviceClient = await cache.GetOrCreateAsync <DeviceClient>(deviceId, async (cacheEntry) =>
                {
                    IAuthenticationMethod auth = null;
                    if (string.IsNullOrEmpty(sasToken))
                    {
                        auth = new DeviceAuthenticationWithSharedAccessPolicyKey(deviceId, this.serverOptions.AccessPolicyName, this.serverOptions.AccessPolicyKey);
                    }
                    else
                    {
                        auth = new DeviceAuthenticationWithToken(deviceId, sasToken);
                    }

                    var newDeviceClient = DeviceClient.Create(
                        this.serverOptions.IoTHubHostName,
                        auth,
                        new ITransportSettings[]
                    {
                        new AmqpTransportSettings(TransportType.Amqp_Tcp_Only)
                        {
                            AmqpConnectionPoolSettings = new AmqpConnectionPoolSettings()
                            {
                                Pooling     = true,
                                MaxPoolSize = (uint)this.serverOptions.MaxPoolSize,
                            }
                        }
                    }
                        );

                    newDeviceClient.OperationTimeoutInMilliseconds = (uint)this.serverOptions.DeviceOperationTimeout;

                    await newDeviceClient.OpenAsync();

                    if (this.serverOptions.DirectMethodEnabled)
                    {
                        await newDeviceClient.SetMethodDefaultHandlerAsync(this.serverOptions.DirectMethodCallback, deviceId);
                    }

                    if (!tokenExpiration.HasValue)
                    {
                        tokenExpiration = DateTime.UtcNow.AddMinutes(this.serverOptions.DefaultDeviceCacheInMinutes);
                    }
                    cacheEntry.SetAbsoluteExpiration(tokenExpiration.Value);
                    cacheEntry.RegisterPostEvictionCallback(this.CacheEntryRemoved, deviceId);

                    this.logger.LogInformation($"Connection to device {deviceId} has been established, valid until {tokenExpiration.Value.ToString()}");


                    registeredDevices.AddDevice(deviceId);

                    return(newDeviceClient);
                });


                return(deviceClient);
            }
            catch (Exception ex)
            {
                this.logger.LogError(ex, $"Could not connect device {deviceId}");
            }

            return(null);
        }