Example #1
0
        public void UploadCertReturnsValidResponseTest()
        {
            using (UndoContext undoContext = UndoContext.Current)
            {
                undoContext.Start();

                BackupVaultServicesManagementClient client = GetServiceClient<BackupVaultServicesManagementClient>();

                string subscriptionId = ConfigurationManager.AppSettings["SubscriptionId"];
                string resourceName = ConfigurationManager.AppSettings["ResourceName"];
                string resourceId = ConfigurationManager.AppSettings["ResourceId"];

                string certFriendlyName = VaultTestHelper.GenerateCertFriendlyName(subscriptionId, resourceName);

                X509Certificate2 cert =
                    VaultTestHelper.CreateSelfSignedCert(VaultTestHelper.DefaultIssuer,
                                                         certFriendlyName,
                                                         VaultTestHelper.DefaultPassword,
                                                         DateTime.UtcNow.AddMinutes(-10),
                                                         DateTime.UtcNow.AddHours(VaultTestHelper.GetCertificateExpiryInHours()));

                string rawCertDataString = Convert.ToBase64String(cert.RawData);
                VaultCredUploadCertRequest vaultCredUploadCertRequest = new VaultCredUploadCertRequest()
                {
                    RawCertificateData = new RawCertificateData()
                    {
                        Certificate = rawCertDataString,
                    },
                };

                VaultCredUploadCertResponse response =
                    client.Vault.UploadCertificate("IdMgmtInternalCert", vaultCredUploadCertRequest, GetCustomRequestHeaders());

                // Response Validation
                Assert.NotNull(response);
                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.NotNull(response.ResourceCertificateAndACSDetails);

                // Basic Validation                
                Assert.False(string.IsNullOrEmpty(response.ResourceCertificateAndACSDetails.GlobalAcsHostName),
                             "Returned Global ACS Host Name shouldn't be null or empty");
                Assert.False(string.IsNullOrEmpty(response.ResourceCertificateAndACSDetails.GlobalAcsNamespace),
                             "Returned Global ACS Namespace shouldn't be null or empty");
                Assert.False(string.IsNullOrEmpty(response.ResourceCertificateAndACSDetails.GlobalAcsRPRealm),
                             "Returned Global ACS RP Realm shouldn't be null or empty");

                // Extra Validation
                Assert.True(string.Equals(VaultTestHelper.DefaultIssuer, response.ResourceCertificateAndACSDetails.Issuer),
                            "Downloaded and uploaded cert Issuers don't match");
                Assert.True(string.Equals(resourceId, response.ResourceCertificateAndACSDetails.ResourceId.ToString()),
                            "Downloaded and uploaded resource IDs don't match");
            }
        }
        /// <summary>
        /// Upload certificate
        /// </summary>
        /// <param name="cert">management certificate</param>
        /// <param name="subscriptionId">subscription Id</param>
        /// <param name="resourceName">resource name</param>
        /// <param name="resourceType">resource type</param>
        /// <param name="resourceGroupName">resource group name</param>
        /// <returns>acs namespace of the uploaded cert</returns>
        private AcsNamespace UploadCert(X509Certificate2 cert, string subscriptionId, string resourceName, string resourceType, string resourceGroupName)
        {
            string rawCertDataString = Convert.ToBase64String(cert.RawData);
            VaultCredUploadCertRequest vaultCredUploadCertRequest = new VaultCredUploadCertRequest()
            {
                RawCertificateData = new RawCertificateData()
                {
                    Certificate = rawCertDataString,
                },
            };

            var vaultCredUploadCertResponse = AzureBackupClient.UploadCertificate("IdMgmtInternalCert", vaultCredUploadCertRequest);

            return new AcsNamespace(vaultCredUploadCertResponse.ResourceCertificateAndACSDetails.GlobalAcsHostName,
                                    vaultCredUploadCertResponse.ResourceCertificateAndACSDetails.GlobalAcsNamespace,
                                    vaultCredUploadCertResponse.ResourceCertificateAndACSDetails.GlobalAcsRPRealm);
        }
 /// <summary>
 /// Uploads vault credential certificate.
 /// </summary>
 /// <param name='operations'>
 /// Reference to the
 /// Microsoft.Azure.Management.BackupServices.IVaultOperations.
 /// </param>
 /// <param name='resourceGroupName'>
 /// Required.
 /// </param>
 /// <param name='resourceName'>
 /// Required.
 /// </param>
 /// <param name='certificateName'>
 /// Required. Name of the certificate.
 /// </param>
 /// <param name='vaultCredUploadCertRequest'>
 /// Required. Certificate parameters.
 /// </param>
 /// <param name='customRequestHeaders'>
 /// Optional. Request header parameters.
 /// </param>
 /// <returns>
 /// The definition of a certificate response.
 /// </returns>
 public static Task<VaultCredUploadCertResponse> UploadCertificateAsync(this IVaultOperations operations, string resourceGroupName, string resourceName, string certificateName, VaultCredUploadCertRequest vaultCredUploadCertRequest, CustomRequestHeaders customRequestHeaders)
 {
     return operations.UploadCertificateAsync(resourceGroupName, resourceName, certificateName, vaultCredUploadCertRequest, customRequestHeaders, CancellationToken.None);
 }
 public VaultCredUploadCertResponse UploadCertificate(string resourceGroupName, string resourceName, string certName, VaultCredUploadCertRequest request)
 {
     return AzureBackupVaultClient.Vault.UploadCertificateAsync(resourceGroupName, resourceName, certName, request, GetCustomRequestHeaders(), CmdletCancellationToken).Result;
 }
 /// <summary>
 /// Uploads vault credential certificate.
 /// </summary>
 /// <param name='operations'>
 /// Reference to the
 /// Microsoft.Azure.Management.BackupServices.IVaultOperations.
 /// </param>
 /// <param name='resourceGroupName'>
 /// Required.
 /// </param>
 /// <param name='resourceName'>
 /// Required.
 /// </param>
 /// <param name='certificateName'>
 /// Required. Name of the certificate.
 /// </param>
 /// <param name='vaultCredUploadCertRequest'>
 /// Required. Certificate parameters.
 /// </param>
 /// <param name='customRequestHeaders'>
 /// Optional. Request header parameters.
 /// </param>
 /// <returns>
 /// The definition of a certificate response.
 /// </returns>
 public static VaultCredUploadCertResponse UploadCertificate(this IVaultOperations operations, string resourceGroupName, string resourceName, string certificateName, VaultCredUploadCertRequest vaultCredUploadCertRequest, CustomRequestHeaders customRequestHeaders)
 {
     return Task.Factory.StartNew((object s) => 
     {
         return ((IVaultOperations)s).UploadCertificateAsync(resourceGroupName, resourceName, certificateName, vaultCredUploadCertRequest, customRequestHeaders);
     }
     , operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
 }