public void AzureWebSites_AddConnectionStrings_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(TestConstants.TestSubscription)) { // Create Azure WebSite portal.WebSites.CreateWebSite(TestConstants.WebSiteName); Assert.IsTrue(portal.WebSites.WebSiteExists(TestConstants.WebSiteName)); // When modifiying the site config, start by getting the existing config. // Otherwise, you might delete important settings, such as default documents. var config = portal.WebSites.GetWebSiteConfig(TestConstants.WebSiteName); var updateParams = portal.WebSites.CreateWebSiteUpdateParameters(config); updateParams.ConnectionStrings.Add(new WebSiteUpdateConfigurationParameters.ConnectionStringInfo { Name = "MyConnectionString", ConnectionString = "Initial Catalog=test", Type = "SQLAzure", }); // Add a new connection string portal.WebSites.UpdateWebSiteConfig(TestConstants.WebSiteName, updateParams); // verify the connection string was added config = portal.WebSites.GetWebSiteConfig(TestConstants.WebSiteName); Assert.AreEqual(1, config.ConnectionStrings.Count); } }
public void AzureCloudServices_CreateHostedService_ReuseExisting() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { // first, create an affinity group in a different location portal.AffinityGroups.CreateAffinityGroup(new Microsoft.WindowsAzure.Management.Models.AffinityGroupCreateParameters { Name = "bvtAffinityGroupEast", Location = "East US", }); portal.CloudServices.CreateHostedService(new HostedServiceCreateParameters { ServiceName = TestConstants.HostedServiceName, AffinityGroup = "bvtAffinityGroupEast", }); // now "create" the duplicate, which will reuse the existing portal.CloudServices.CreateHostedService(new HostedServiceCreateParameters { ServiceName = TestConstants.HostedServiceName, AffinityGroup = "bvtAffinityGroupWest", }); var service = portal.CloudServices.GetHostedService(TestConstants.HostedServiceName); Assert.AreEqual("bvtAffinityGroupEast", service.Properties.AffinityGroup, true); } }
public void AzureWebSites_E2E_FTP_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(DefaultSubscription)) { // first check if this website exist by some reason from previous Bvt run if (portal.WebSites.WebSiteExists("mywebsite1112")) { portal.WebSites.DeleteWebSite("mywebsite1112"); } // Create Azure WebSite WebSite site = portal.WebSites.CreateWebSite("mywebsite1112"); Assert.IsTrue(portal.WebSites.WebSiteExists("mywebsite1112")); // Deploy website content portal.WebSites.PublishWebSite(Path.GetFullPath("TestEasyWebSite"), "mywebsite1112", PublishMethod.Ftp, siteRootRelativePath: "musicstore"); portal.WebSites.PublishDirectory(Path.GetFullPath("TestEasyWebSite"), "mywebsite1112", PublishMethod.Ftp, siteRootRelativePath: "packages"); // at .../site/wwwroot/packages portal.WebSites.PublishDirectory(Path.GetFullPath("TestEasyWebSite"), "mywebsite1112", PublishMethod.Ftp, siteRootRelativePath: "..\\packages"); // .../site/packages portal.WebSites.PublishDirectory(Path.GetFullPath("TestEasyWebSite"), "mywebsite1112", PublishMethod.Ftp, siteRootRelativePath: "..\\..\\packages"); // .../packages // Ping website Assert.IsTrue(TestEasyHelpers.Web.PingUrl(site.GetUrl() + "/musicstore/default.html")); } }
public void AzureCloudServices_SwapDeployment_StagingToProduction() { var packagePath = Path.GetFullPath("SamplePackage.cspkg"); var configPath = Path.GetFullPath("SampleServiceConfiguration.Cloud.cscfg"); // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(TestConstants.TestSubscription)) { var webRole = portal.CloudServices.DeployRole(packagePath, configPath, deploymentSlot: DeploymentSlot.Staging); // wait for webRole to populate portal.CloudServices.WaitForRoleToRespond(webRole, 5000 /* increase timeout here to 600000 in real tests */); var deployment = portal.CloudServices.GetDeploymentBySlot(webRole.HostedService, DeploymentSlot.Staging); Assert.IsNotNull(deployment); portal.CloudServices.SwapDeployment(webRole.HostedService, new DeploymentSwapParameters { SourceDeployment = webRole.Deployment.Name, }); deployment = portal.CloudServices.GetDeploymentBySlot(webRole.HostedService, DeploymentSlot.Production); Assert.IsNotNull(deployment); deployment = portal.CloudServices.GetDeploymentBySlot(webRole.HostedService, DeploymentSlot.Staging); Assert.IsNull(deployment); } }
public void AzureSql_PublishDatabase_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(DefaultSubscription)) { // create two databases from scratch (they are empty but for feature demonstration its ok) var databaseSource = portal.Sql.CreateSqlDatabase("mytestdbxs"); var server = databaseSource.Server; var databaseDestination = portal.Sql.CreateSqlDatabase("mytestdbxd", server); // now use WebDeploy to publish source database to destination including data(!). // Note: that calling publish database can be called sequentially and next time would bring only // database updates. portal.Sql.PublishDatabase( WebDeployDatabaseType.FullSql, databaseSource.ConnectionString, WebDeployDatabaseType.FullSql, databaseDestination.ConnectionString, includeData: true); // now remove database and server server.DropDatabase(databaseSource); server.DropDatabase(databaseDestination); portal.Sql.DeleteSqlServer(server.Name); // check if server was deleted Assert.IsNull(portal.Sql.GetSqlServer(server.Name)); } }
public void AffinityGroups_EnsureAffinityGroupExists_CreatesNewGroup() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { portal.AffinityGroups.EnsureAffinityGroupExists(TestConstants.AffinityGroupName); Assert.IsNotNull(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName)); } }
public void Cleanup() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { if (portal.WebSites.WebSiteExists(TestConstants.WebSiteName)) { portal.WebSites.DeleteWebSite(TestConstants.WebSiteName); } } }
public void AzureVirtualMachines_GetListOfAllAvailableOsImages_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(DefaultSubscription)) { var oses = portal.VirtualMachines.GetOsImages(); Assert.IsTrue(oses.Any()); } }
public void AzureVirtualMachines_GetListOfAllAvailableOsImages_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(TestConstants.TestSubscription)) { var oses = portal.VirtualMachines.GetOsImages(); Assert.IsTrue(oses.Any()); } }
public void TestCleanup() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { if (portal.CloudServices.GetHostedService(TestConstants.HostedServiceName) != null) { portal.CloudServices.DeleteHostedService(TestConstants.HostedServiceName); } } }
public void TestCleanup() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { if (portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName) != null) { portal.AffinityGroups.DeleteAffinityGroup(TestConstants.AffinityGroupName); } } }
public void AzureStorageServices_CleanupOnDisposal() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { portal.Storage.CreateStorageService(TestConstants.StorageServiceName); } using (var portal = new AzurePortal(TestConstants.TestSubscription)) { var service = portal.Storage.GetStorageService(TestConstants.StorageServiceName); Assert.IsNull(service); } }
public void AffinityGroups_Create_Delete_E2E() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { portal.AffinityGroups.CreateAffinityGroup(TestConstants.AffinityGroupName); Assert.IsNotNull(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName)); portal.AffinityGroups.DeleteAffinityGroup(TestConstants.AffinityGroupName); Assert.IsNull(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName)); } }
public void AzureCloudServices_CleanupHostedServicesAfterTest() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { portal.CloudServices.CreateHostedService(TestConstants.HostedServiceName); Assert.IsNotNull(portal.CloudServices.GetHostedService(TestConstants.HostedServiceName)); } // verify hosted service was cleaned up using (var portal = new AzurePortal(TestConstants.TestSubscription)) { Assert.IsNull(portal.CloudServices.GetHostedService(TestConstants.HostedServiceName)); } }
public void AffinityGroups_CleanedUpAfterTest() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { portal.AffinityGroups.CreateAffinityGroup(TestConstants.AffinityGroupName); Assert.IsNotNull(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName)); } using (var portal = new AzurePortal(TestConstants.TestSubscription)) { // affinity group should have been cleaned up when previous Portal instance was disposed. Assert.IsNull(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName)); } }
public void AzureWebSites_E2E_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(TestConstants.TestSubscription)) { // Create Azure WebSite var site = portal.WebSites.CreateWebSite(TestConstants.WebSiteName); Assert.IsTrue(portal.WebSites.WebSiteExists(TestConstants.WebSiteName)); // Deploy website content portal.WebSites.PublishWebSite(Path.GetFullPath("TestEasyWebSite"), TestConstants.WebSiteName); // Ping website Assert.IsTrue(TestEasyHelpers.Web.PingUrl(site.GetUrl() + "/default.html")); } }
public void AffinityGroups_Waml_Create_Delete_E2E() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { portal.AffinityGroups.CreateAffinityGroup(new Microsoft.WindowsAzure.Management.Models.AffinityGroupCreateParameters { Name = TestConstants.AffinityGroupName, Location = "West US", }); Assert.IsNotNull(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName)); portal.AffinityGroups.DeleteAffinityGroup(TestConstants.AffinityGroupName); Assert.IsNull(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName)); } }
public void AzureCloudServices_CreateHostedServiceFromWaml_EnsureAffinityGroupExists() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { if (portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName) != null) { portal.AffinityGroups.DeleteAffinityGroup(TestConstants.AffinityGroupName); } portal.CloudServices.CreateHostedService(new HostedServiceCreateParameters { ServiceName = TestConstants.HostedServiceName, AffinityGroup = TestConstants.AffinityGroupName, }); Assert.IsNotNull(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName)); } }
public void AzureCloudServices_CreateHostedServiceFromWaml_EnsureAffinityGroupExists() { using (var portal = new AzurePortal(TestConstants.TestSubscription)) { if(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName) != null) { portal.AffinityGroups.DeleteAffinityGroup(TestConstants.AffinityGroupName); } portal.CloudServices.CreateHostedService(new HostedServiceCreateParameters { ServiceName = TestConstants.HostedServiceName, AffinityGroup = TestConstants.AffinityGroupName, }); Assert.IsNotNull(portal.AffinityGroups.GetAffinityGroup(TestConstants.AffinityGroupName)); } }
public void AzureSql_E2E_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(TestConstants.TestSubscription)) { // Create Azure Sql server. Notice that here we specified admin user name and password, however all parameters // are optional. If user and password are not specified, TestEasy default ones will be used. var server = portal.Sql.CreateSqlServer(user: "******", password: "******"); // by default when we use Sql.CreateServer, current machine is added to firewall rules by TestEasy // however you can add your own server firewall rules var rule = server.CreateFirewallRule("mydummyrule", "10.0.0.1", "10.0.0.100"); Assert.IsTrue(server.FirewallRuleExists(rule.Name)); Assert.AreEqual("10.0.0.1", rule.StartIPAddress); Assert.AreEqual("10.0.0.100", rule.EndIPAddress); // delete now our firewall rule server.DeleteFirewallRule(rule.Name); Assert.IsFalse(server.FirewallRuleExists(rule.Name)); // create a database on just created server var database = server.CreateDatabase("MyTestDatabase"); // check if database was created for server Assert.AreEqual(1, server.Databases.Count()); // just dummy check that connection string is not empty Assert.IsFalse(string.IsNullOrEmpty(database.ConnectionString)); // now remove database server.DropDatabase(database); Assert.AreEqual(0, server.Databases.Count()); // remove server portal.Sql.DeleteSqlServer(server.Name); // check if server was deleted Assert.IsNull(portal.Sql.GetSqlServer(server.Name)); } }
public void AzureCloudServices_FastWebRoleCreate_Test() { var packagePath = Path.GetFullPath("SamplePackage.cspkg"); var configPath = Path.GetFullPath("SampleServiceConfiguration.Cloud.cscfg"); // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(TestConstants.TestSubscription)) { var webRole = portal.CloudServices.DeployRole(packagePath, configPath); // wait for webRole to populate portal.CloudServices.WaitForRoleToRespond(webRole, 5000 /* increase timeout here to 600000 in real tests */); // now remove WebRole portal.CloudServices.DeleteRole(webRole); Assert.IsNull(portal.CloudServices.GetDeployment(webRole.HostedService, webRole.Deployment.Name)); } }
public void AzureSql_E2E_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(DefaultSubscription)) { // Create Azure Sql server. Notice that here we specified admin user name and password, however all parameters // are optional. If user and password are not specified, TestEasy default ones will be used. var server = portal.Sql.CreateSqlServer(user: "******", password: "******"); // by default when we use Sql.CreateServer, current machine is added to firewall rules by TestEasy // however you can add your own server firewall rules var rule = server.CreateFirewallRule("mydummyrule", "10.0.0.1", "10.0.0.100"); Assert.IsTrue(server.FirewallRuleExists(rule.Name)); Assert.AreEqual("10.0.0.1", rule.StartIPAddress); Assert.AreEqual("10.0.0.100", rule.EndIPAddress); // delete now our firewall rule server.DeleteFirewallRule(rule.Name); Assert.IsFalse(server.FirewallRuleExists(rule.Name)); // create a database on just created server var database = server.CreateDatabase("MyTestDatabase"); // check if database was created for server Assert.AreEqual(1, server.Databases.Count()); // just dummy check that connection string is not empty Assert.IsFalse(string.IsNullOrEmpty(database.ConnectionString)); // now remove database server.DropDatabase(database); Assert.AreEqual(0, server.Databases.Count()); // remove server portal.Sql.DeleteSqlServer(server.Name); // check if server was deleted Assert.IsNull(portal.Sql.GetSqlServer(server.Name)); } }
public void AzureSql_FastCreateDatabase_Test() { TestEasyLog.Instance.StartScenario("Sample for quick database creation"); // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(TestConstants.TestSubscription)) { TestEasyLog.Instance.StartScenario("Create database"); // This is fastest way to create database from scratch. // Note: if you don't specify server name here, new server will be created for your database. // If you would remove server at the end it would be ok, however if each test would createa separate // server for each scenario it may overload subscription capacity. To avoid that make sure you reuse // servers and databases accross scenario of the same test class, unless it is needed by scenario to // have fresh objects. // In this API default user and password would be used to create server and your machine's IP would be // automatically added to firewallrules on a new server. var database = portal.Sql.CreateSqlDatabase("mytestdbx"); TestEasyLog.Instance.EndScenario("Database created"); // check if database was created for server Assert.AreEqual(1, database.Server.Databases.Count()); // just dummy check that connection string is not empty Assert.IsFalse(string.IsNullOrEmpty(database.ConnectionString)); TestEasyLog.Instance.StartScenario("Drop database"); // now remove database and server database.Server.DropDatabase(database); TestEasyLog.Instance.EndScenario("Database dropped"); // check if server was deleted Assert.IsFalse(database.Server.DatabaseExists(database)); } TestEasyLog.Instance.EndScenario("Sample complete"); }
public void AzureSql_ExplicitResourceCleanup_Test() { // Create an entry point to all Azure functionality var portal = new AzurePortal(DefaultSubscription); var database = portal.Sql.CreateSqlDatabase("mytestdbx"); // check if database was created for server Assert.IsFalse(string.IsNullOrEmpty(database.ConnectionString)); // It is important to call this method in the end of your test to clean up all Azure resources // you have used explicitly or implicitly while using TestEasy API. TestEasy remembers all resources // that were created and frees them. If we don't free resources subscription will reach it's limits soon, // and tests will be blocked. // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. portal.CleanupResources(); // check if server was deleted Assert.IsFalse(database.Server.DatabaseExists(database)); }
public void AzureSql_FastCreateWebSiteWithDatabase_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(DefaultSubscription)) { // This is fastest way to create database from scratch. // Note: if you don't specify server name here, new server will be created for your database. // If you would remove server at the end it would be ok, however if each test would createa separate // server for each scenario it may overload subscription capacity. To avoid that make sure you reuse // servers and databases accross scenario of the same test class, unless it is needed by scenario to // have fresh objects. // In this API default user and password would be used to create server and your machine's IP would be // automatically added to firewallrules on a new server. var database = portal.Sql.CreateSqlDatabase("mytestdbx"); // check if database was created for server Assert.AreEqual(1, database.Server.Databases.Count()); // just dummy check that connection string is not empty Assert.IsFalse(string.IsNullOrEmpty(database.ConnectionString)); var site = portal.WebSites.CreateWebSite( connectionStringInfo: new Microsoft.WindowsAzure.Management.WebSites.Models.WebSiteUpdateConfigurationParameters.ConnectionStringInfo { Name = "DefaultConnectionString", ConnectionString = database.ConnectionString, Type = "SQLAzure", }); Assert.IsTrue(TestEasyHelpers.Web.PingUrl(site.GetUrl())); // now remove database and server database.Server.DropDatabase(database); portal.Sql.DeleteSqlServer(database.Server.Name); // check if server was deleted Assert.IsNull(portal.Sql.GetSqlServer(database.Server.Name)); } }
public void AzureSql_FastCreateWebSiteWithDatabase_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(TestConstants.TestSubscription)) { // This is fastest way to create database from scratch. // Note: if you don't specify server name here, new server will be created for your database. // If you would remove server at the end it would be ok, however if each test would createa separate // server for each scenario it may overload subscription capacity. To avoid that make sure you reuse // servers and databases accross scenario of the same test class, unless it is needed by scenario to // have fresh objects. // In this API default user and password would be used to create server and your machine's IP would be // automatically added to firewallrules on a new server. var database = portal.Sql.CreateSqlDatabase("mytestdbx"); // check if database was created for server Assert.AreEqual(1, database.Server.Databases.Count()); // just dummy check that connection string is not empty Assert.IsFalse(string.IsNullOrEmpty(database.ConnectionString)); var site = portal.WebSites.CreateWebSite( connectionStringInfo: new WebSiteUpdateConfigurationParameters.ConnectionStringInfo { Name = "DefaultConnectionString", ConnectionString = database.ConnectionString, Type = "SQLAzure", }); Assert.IsTrue(TestEasyHelpers.Web.PingUrl(site.GetUrl())); // now remove database and server database.Server.DropDatabase(database); portal.Sql.DeleteSqlServer(database.Server.Name); // check if server was deleted Assert.IsNull(portal.Sql.GetSqlServer(database.Server.Name)); } }
public void AzureSql_PublishDatabase_Test() { // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. using (var portal = new AzurePortal(TestConstants.TestSubscription)) { // create two databases from scratch (they are empty but for feature demonstration its ok) var databaseSource = portal.Sql.CreateSqlDatabase("mytestdbxs"); var server = databaseSource.Server; var databaseDestination = portal.Sql.CreateSqlDatabase("mytestdbxd", server); // now use WebDeploy to publish source database to destination including data(!). // Note: that calling publish database can be called sequentially and next time would bring only // database updates. portal.Sql.PublishDatabase( WebDeployDatabaseType.FullSql, databaseSource.ConnectionString, WebDeployDatabaseType.FullSql, databaseDestination.ConnectionString, includeData: true); // now remove database and server server.DropDatabase(databaseSource); server.DropDatabase(databaseDestination); portal.Sql.DeleteSqlServer(server.Name); // check if server was deleted Assert.IsNull(portal.Sql.GetSqlServer(server.Name)); } }
public void AzureSql_ExplicitResourceCleanup_Test() { // Create an entry point to all Azure functionality var portal = new AzurePortal(TestConstants.TestSubscription); var database = portal.Sql.CreateSqlDatabase("mytestdbx"); // check if database was created for server Assert.AreEqual(1, database.Server.Databases.Count()); Assert.IsFalse(string.IsNullOrEmpty(database.ConnectionString)); // It is important to call this method in the end of your test to clean up all Azure resources // you have used explicitly or implicitly while using TestEasy API. TestEasy remembers all resources // that were created and frees them. If we don't free resources subscription will reach it's limits soon, // and tests will be blocked. // Note: !!! it is recommended though to use "using" statement since it would call Dispose even in // the case of exception, which would ensure all resources cleaned up. portal.CleanupResources(); // check if server was deleted Assert.IsFalse(database.Server.DatabaseExists(database)); }