Azure Backup One SDK

locker/AzureBackup/BackupServices.Tests/ScenarioTests/AzureBackupItemTests.cs

@@ -0,0 +1,141 @@
+//
+// Copyright (c) Microsoft.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+using Microsoft.Azure.Management.BackupServices;
+using Microsoft.Azure.Management.BackupServices.Models;
+using Microsoft.Azure.Test;
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace BackupServices.Tests
+{
+    public class AzureBackupItemTests : BackupServicesTestsBase
+    {
+        [Fact]
+        public void EnableAzureBackupProtectionTest()
+        {
+            using (UndoContext context = UndoContext.Current)
+            {
+                var client = GetServiceClient<BackupServicesManagementClient>();
+                context.Start();
+                SetProtectionRequestInput input = new SetProtectionRequestInput();
+                input.PolicyId = ConfigurationManager.AppSettings["PolicyId"];
+                input.ProtectableObjects.Add(ConfigurationManager.AppSettings["AzureBackupItemName"]);
+                input.ProtectableObjectType = ConfigurationManager.AppSettings["DataSourceType"];
+                var response = client.DataSource.EnableProtection(GetCustomRequestHeaders(), input);
+                Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
+            }
+        }
+
+        [Fact]
+        public void DisableAzureBackupProtectionTest()
+        {
+            using (UndoContext context = UndoContext.Current)
+            {
+                var client = GetServiceClient<BackupServicesManagementClient>();
+                context.Start();
+                RemoveProtectionRequestInput input1 = new RemoveProtectionRequestInput();
+                input1.RemoveProtectionOption = "RetainBackupData";
+                string containerName = ConfigurationManager.AppSettings["ContainerName"];
+                string dataSourceType = ConfigurationManager.AppSettings["DataSourceType"];
+                string dataSourceId = ConfigurationManager.AppSettings["DataSourceId"];
+                var response = client.DataSource.DisableProtection(GetCustomRequestHeaders(),
+                    containerName,
+                    dataSourceType,
+                    dataSourceId,
+                    input1);
+                Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
+            }
+        }
+
+        [Fact]
+        public void ListAzureBackupItemPOTest()
+        {
+            using (UndoContext context = UndoContext.Current)
+            {
+                context.Start();
+
+                POQueryParameter POQueryParam = new POQueryParameter()
+                {
+                    Status = null,
+                    Type = null
+                };
+
+                var client = GetServiceClient<BackupServicesManagementClient>();
+
+                var response = client.ProtectableObject.ListAsync(POQueryParam, GetCustomRequestHeaders()).Result;
+
+                Assert.True(response.ProtectableObject.ResultCount > 0, "Protectable Object Result count can't be less than 1");
+
+                foreach (var po in response.ProtectableObject.Objects)
+                {
+                    Assert.True(!string.IsNullOrEmpty(po.ContainerName), "ContainerName can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(po.ContainerType), "ContainerType can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(po.FriendlyName), "FriendlyName can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(po.Type), "Type can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(po.InstanceId), "Name can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(po.Name), "Name can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(po.ParentContainerFriendlyName), "ParentContainerFriendlyName can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(po.ParentContainerName), "ParentContainerName can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(po.ProtectionStatus), "ProtectionStatus can't be null or empty");
+                }
+
+                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            }
+        }
+
+        [Fact]
+        public void ListAzureBackupItemDSTest()
+        {
+            using (UndoContext context = UndoContext.Current)
+            {
+                context.Start();
+
+                DataSourceQueryParameter DSQueryParam = new DataSourceQueryParameter()
+                {
+                    ProtectionStatus = null,
+                    Status = null,
+                    Type = null
+                };
+
+                var client = GetServiceClient<BackupServicesManagementClient>();
+
+                var response = client.DataSource.ListAsync(DSQueryParam, GetCustomRequestHeaders()).Result;
+                foreach (var ds in response.DataSources.Objects)
+                {
+                    Assert.True(!string.IsNullOrEmpty(ds.ContainerName), "ContainerName can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(ds.ContainerType), "ContainerType can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(ds.FriendlyName), "FriendlyName can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(ds.Type), "Type can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(ds.RecoveryPointsCount.ToString()), "RecoveryPointsCount can't be  null or empty");
+                    Assert.True(!string.IsNullOrEmpty(ds.ProtectableObjectName), "ProtectableObjectName can't be  null or empty");
+                    Assert.True(!string.IsNullOrEmpty(ds.InstanceId), "Name can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(ds.Name), "WorkloadType can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(ds.ProtectionStatus), "ProtectionStatus can't be null or empty");
+                    Assert.True(!string.IsNullOrEmpty(ds.Status), "Status can't be null or empty"); ;
+                }
+
+                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            }
+        }
+    }
+}

locker/AzureBackup/BackupServices.Tests/ScenarioTests/BackUpTests.cs

@@ -0,0 +1,30 @@
+using Microsoft.Azure.Management.BackupServices.Models;
+using Microsoft.Azure.Management.BackupServices;
+using Microsoft.Azure.Test;
+using System.Net;
+using Xunit;
+using System.Configuration;
+using System;
+
+namespace BackupServices.Tests
+{
+    public class BackUpTests : BackupServicesTestsBase
+    {
+        [Fact]
+        public void TriggerBackUpTest()
+        {
+            using (UndoContext context = UndoContext.Current)
+            {
+                context.Start();
+                var client = GetServiceClient<BackupServicesManagementClient>();
+
+                string containerName = ConfigurationManager.AppSettings["ContainerName"];
+                string dataSourceType = ConfigurationManager.AppSettings["DataSourceType"];
+                string dataSourceId = ConfigurationManager.AppSettings["DataSourceId"];
+
+                var response = client.BackUp.TriggerBackUp(GetCustomRequestHeaders(), containerName, dataSourceType, dataSourceId);
+                Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
+            }
+        }
+    }
+}

locker/AzureBackup/BackupServices.Tests/ScenarioTests/BackupServicesTestBase.cs

@@ -0,0 +1,132 @@
+//
+// Copyright (c) Microsoft.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Security.Cryptography;
+using System.Text;
+using Microsoft.Azure.Management.BackupServices;
+using Microsoft.Azure.Management.BackupServices.Models;
+using Microsoft.Azure.Common.Internals;
+using Hyak.Common.TransientFaultHandling;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Xml;
+using Xunit;
+using Microsoft.Azure.Test;
+using Newtonsoft.Json;
+using Microsoft.Azure.Test.HttpRecorder;
+using System.Configuration;
+using Microsoft.Azure;
+using System.Reflection;
+using System.Net.Http;
+using System.Net.Security;
+
+namespace BackupServices.Tests
+{
+    public class BackupServicesTestsBase : TestBase
+    {
+        public new static T GetServiceClient<T>() where T : class
+        {
+            var factory = (TestEnvironmentFactory)new CSMTestEnvironmentFactory();
+
+            var testEnvironment = factory.GetTestEnvironment();
+            //testEnvironment.BaseUri = new Uri("https://localhost:8443/RdfeProxy.svc/");
+            ServicePointManager.ServerCertificateValidationCallback = IgnoreCertificateErrorHandler;
+
+            BackupServicesManagementClient client;
+
+            string resourceName = ConfigurationManager.AppSettings["ResourceName"];
+            string resourceGroupName = ConfigurationManager.AppSettings["ResourceGroupName"];
+            if (testEnvironment.UsesCustomUri())
+            {
+                client = new BackupServicesManagementClient(
+                    resourceName,
+                    resourceGroupName,
+                    testEnvironment.Credentials as SubscriptionCloudCredentials,
+                    testEnvironment.BaseUri);
+            }
+
+            else
+            {
+                client = new BackupServicesManagementClient(
+                    resourceName,
+                    resourceGroupName,
+                    testEnvironment.Credentials as SubscriptionCloudCredentials);
+            }
+
+            return GetServiceClient<T>(factory, client);
+        }
+
+
+        public static T GetServiceClient<T>(TestEnvironmentFactory factory, BackupServicesManagementClient client) where T : class
+        {
+            TestEnvironment testEnvironment = factory.GetTestEnvironment();
+
+            HttpMockServer instance;
+            try
+            {
+                instance = HttpMockServer.CreateInstance();
+            }
+            catch (ApplicationException)
+            {
+                HttpMockServer.Initialize("TestEnvironment", "InitialCreation");
+                instance = HttpMockServer.CreateInstance();
+            }
+            T obj2 = typeof(T).GetMethod("WithHandler", new Type[1]
+            {
+                typeof (DelegatingHandler)
+            }).Invoke((object)client, new object[1]
+            {
+                (object) instance
+            }) as T;
+
+            if (HttpMockServer.Mode == HttpRecorderMode.Record)
+            {
+                HttpMockServer.Variables[TestEnvironment.SubscriptionIdKey] = testEnvironment.SubscriptionId;
+            }
+
+            if (HttpMockServer.Mode == HttpRecorderMode.Playback)
+            {
+                PropertyInfo property1 = typeof(T).GetProperty("LongRunningOperationInitialTimeout", typeof(int));
+                PropertyInfo property2 = typeof(T).GetProperty("LongRunningOperationRetryTimeout", typeof(int));
+                if (property1 != (PropertyInfo)null && property2 != (PropertyInfo)null)
+                {
+                    property1.SetValue((object)obj2, (object)0);
+                    property2.SetValue((object)obj2, (object)0);
+                }
+            }
+            return obj2;
+        }
+
+        private static bool IgnoreCertificateErrorHandler
+           (object sender,
+           System.Security.Cryptography.X509Certificates.X509Certificate certificate,
+           System.Security.Cryptography.X509Certificates.X509Chain chain,
+           SslPolicyErrors sslPolicyErrors)
+        {
+            return true;
+        }
+
+        public static CustomRequestHeaders GetCustomRequestHeaders()
+        {
+            return new CustomRequestHeaders()
+            {
+                ClientRequestId = Guid.NewGuid().ToString(),
+            };
+        }
+    }
+}

locker/AzureBackup/BackupServices.Tests/ScenarioTests/ContainerTests.cs

@@ -0,0 +1,80 @@
+using Microsoft.Azure.Management.BackupServices;
+using Microsoft.Azure.Management.BackupServices.Models;
+using Microsoft.Azure.Test;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+using System.Configuration;
+using BackupServices.Tests.Helpers;
+
+namespace BackupServices.Tests
+{
+    public class ContainerTests : BackupServicesTestsBase
+    {
+        [Fact]
+        public void ListContainersReturnsValidResponseTest()
+        {
+            using (UndoContext undoContext = UndoContext.Current)
+            {
+                undoContext.Start();
+
+                BackupServicesManagementClient client = GetServiceClient<BackupServicesManagementClient>();
+
+                ListContainerResponse response = client.Container.List(string.Empty, GetCustomRequestHeaders());
+
+                // Response Validation
+                Assert.NotNull(response);
+                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+                Assert.True(response.ResultCount > 0, "Should return at least one container");
+                Assert.True(response.Objects.Count > 0, "Should return at least one container");
+            }
+        }
+
+        [Fact]
+        public void RegisterContainersReturnsValidResponseTest()
+        {
+            using (UndoContext undoContext = UndoContext.Current)
+            {
+                undoContext.Start();
+
+                BackupServicesManagementClient client = GetServiceClient<BackupServicesManagementClient>();
+                string containerName = ConfigurationManager.AppSettings["ContainerName"];
+                var inputRequest = new RegisterContainerRequestInput();
+                inputRequest.ContainerType = "IaasVMContainer";
+                inputRequest.ContainerUniqueNameList = new List<string>();
+                inputRequest.ContainerUniqueNameList.Add(containerName);
+
+                var response = client.Container.Register(inputRequest, GetCustomRequestHeaders());
+
+                // Response Validation
+                Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
+                Assert.NotNull(response);
+            }
+        }
+
+        [Fact]
+        public void UnRegisterContainersReturnsValidResponseTest()
+        {
+            using (UndoContext undoContext = UndoContext.Current)
+            {
+                undoContext.Start();
+
+                BackupServicesManagementClient client = GetServiceClient<BackupServicesManagementClient>();
+                string containerName = ConfigurationManager.AppSettings["ContainerName"];
+                var inputRequest = new UnregisterContainerRequestInput();
+                inputRequest.ContainerType = "IaasVMContainer";
+                inputRequest.ContainerUniqueName = containerName;
+
+                var response = client.Container.Unregister(inputRequest, GetCustomRequestHeaders());
+
+                // Response Validation
+                Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
+                Assert.NotNull(response);
+            }
+        }
+    }
+}