public void BaseSetup() { if (AzureSession.DataStore != null && !(AzureSession.DataStore is MemoryDataStore)) { AzureSession.DataStore = new MemoryDataStore(); } currentProfile = new AzureSMProfile(); if (currentProfile.Context.Subscription == null) { var newGuid = Guid.NewGuid(); var client = new ProfileClient(currentProfile); client.AddOrSetAccount(new AzureAccount { Id = "test", Type = AzureAccount.AccountType.User, Properties = new Dictionary<AzureAccount.Property, string> { {AzureAccount.Property.Subscriptions, newGuid.ToString()} } }); client.AddOrSetSubscription( new AzureSubscription { Id = newGuid, Name = "test", Environment = EnvironmentName.AzureCloud, Account = "test" }); client.SetSubscriptionAsDefault(newGuid, "test"); } AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory(); }
public void ProcessShowWebsiteTest() { // Setup var mockClient = new Mock<IWebsitesClient>(); mockClient.Setup(c => c.GetWebsite("website1", null)) .Returns(new Site { Name = "website1", WebSpace = "webspace1", HostNames = new[] {"website1.cloudapp.com"} }); // Test ShowAzureWebsiteCommand showAzureWebsiteCommand = new ShowAzureWebsiteCommand { CommandRuntime = new MockCommandRuntime(), Name = "website1", WebsitesClient = mockClient.Object }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription{Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; // Show existing website showAzureWebsiteCommand.ExecuteCmdlet(); }
public void SwitchesSlots() { // Setup var mockClient = new Mock<IWebsitesClient>(); string slot1 = WebsiteSlotName.Production.ToString(); string slot2 = "staging"; mockClient.Setup(c => c.GetWebsiteSlots("website1")) .Returns(new List<Site> { new Site { Name = "website1", WebSpace = "webspace1" }, new Site { Name = "website1(staging)", WebSpace = "webspace1" } }); mockClient.Setup(f => f.GetSlotName("website1")).Returns(slot1); mockClient.Setup(f => f.GetSlotName("website1(staging)")).Returns(slot2); mockClient.Setup(f => f.SwitchSlots("webspace1", "website1(staging)", slot1, slot2)).Verifiable(); mockClient.Setup(f => f.GetWebsiteNameFromFullName("website1")).Returns("website1"); // Test SwitchAzureWebsiteSlotCommand switchAzureWebsiteCommand = new SwitchAzureWebsiteSlotCommand { CommandRuntime = new MockCommandRuntime(), WebsitesClient = mockClient.Object, Name = "website1", Force = true }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription { Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; // Switch existing website switchAzureWebsiteCommand.ExecuteCmdlet(); mockClient.Verify(c => c.SwitchSlots("webspace1", "website1", slot1, slot2), Times.Once()); }
public List <AzureSubscription> GetSubscriptions(AzureSMProfile profile) { string subscriptions = string.Empty; List <AzureSubscription> subscriptionsList = new List <AzureSubscription>(); if (Properties.ContainsKey(Property.Subscriptions)) { subscriptions = Properties[Property.Subscriptions]; } foreach (var subscription in subscriptions.Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries)) { try { Guid subscriptionId = new Guid(subscription); Debug.Assert(profile.Subscriptions.ContainsKey(subscriptionId)); subscriptionsList.Add(profile.Subscriptions[subscriptionId]); } catch { // Skip } } return(subscriptionsList); }
public List<AzureSubscription> GetSubscriptions(AzureSMProfile profile) { string subscriptions = string.Empty; List<AzureSubscription> subscriptionsList = new List<AzureSubscription>(); if (Properties.ContainsKey(Property.Subscriptions)) { subscriptions = Properties[Property.Subscriptions]; } foreach (var subscription in subscriptions.Split(new [] {','}, StringSplitOptions.RemoveEmptyEntries)) { try { Guid subscriptionId = new Guid(subscription); Debug.Assert(profile.Subscriptions.ContainsKey(subscriptionId)); subscriptionsList.Add(profile.Subscriptions[subscriptionId]); } catch { // Skip } } return subscriptionsList; }
public void DisableAzureWebsiteApplicationDiagnosticApplication() { // Setup websitesClientMock.Setup(f => f.DisableApplicationDiagnostic( websiteName, WebsiteDiagnosticOutput.FileSystem, null)); disableAzureWebsiteApplicationDiagnosticCommand = new DisableAzureWebsiteApplicationDiagnosticCommand() { CommandRuntime = commandRuntimeMock.Object, Name = websiteName, WebsitesClient = websitesClientMock.Object, File = true, }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription{Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; // Test disableAzureWebsiteApplicationDiagnosticCommand.ExecuteCmdlet(); // Assert websitesClientMock.Verify(f => f.DisableApplicationDiagnostic( websiteName, WebsiteDiagnosticOutput.FileSystem, null), Times.Once()); commandRuntimeMock.Verify(f => f.WriteObject(true), Times.Never()); }
public void ListWebHostingPlansTest() { // Setup var clientMock = new Mock<IWebsitesClient>(); clientMock.Setup(c => c.ListWebSpaces()) .Returns(new[] {new WebSpace {Name = "webspace1"}, new WebSpace {Name = "webspace2"}}); clientMock.Setup(c => c.ListWebHostingPlans()) .Returns(new List<WebHostingPlan> { new WebHostingPlan {Name = "Plan1", WebSpace = "webspace1"}, new WebHostingPlan { Name = "Plan2", WebSpace = "webspace2" } }); // Test var command = new GetAzureWebHostingPlanCommand { CommandRuntime = new MockCommandRuntime(), WebsitesClient = clientMock.Object }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription{Id = new Guid(subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(subscriptionId)] = subscription; command.ExecuteCmdlet(); var plans = System.Management.Automation.LanguagePrimitives.GetEnumerable(((MockCommandRuntime)command.CommandRuntime).OutputPipeline).Cast<WebHostingPlan>(); Assert.NotNull(plans); Assert.Equal(2, plans.Count()); Assert.True(plans.Any(p => (p).Name.Equals("Plan1") && (p).WebSpace.Equals("webspace1"))); Assert.True(plans.Any(p => (p).Name.Equals("Plan2") && (p).WebSpace.Equals("webspace2"))); }
public void AddsAzureEnvironment() { var profile = new AzureSMProfile(); Mock<ICommandRuntime> commandRuntimeMock = new Mock<ICommandRuntime>(); AddAzureEnvironmentCommand cmdlet = new AddAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Name = "Katal", PublishSettingsFileUrl = "http://microsoft.com", ServiceEndpoint = "endpoint.net", ManagementPortalUrl = "management portal url", StorageEndpoint = "endpoint.net", GalleryEndpoint = "http://galleryendpoint.com", Profile = profile }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); commandRuntimeMock.Verify(f => f.WriteObject(It.IsAny<PSAzureEnvironment>()), Times.Once()); ProfileClient client = new ProfileClient(profile); AzureEnvironment env = client.GetEnvironmentOrDefault("KaTaL"); Assert.Equal(env.Name, cmdlet.Name); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.PublishSettingsFileUrl], cmdlet.PublishSettingsFileUrl); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.ServiceManagement], cmdlet.ServiceEndpoint); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.ManagementPortalUrl], cmdlet.ManagementPortalUrl); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.Gallery], "http://galleryendpoint.com"); }
public static AzureSMProfile CreateAzureSMProfile(string storageAccount) { var profile = new AzureSMProfile(); var client = new ProfileClient(profile); var tenantId = Guid.NewGuid(); var subscriptionId = Guid.NewGuid(); var account = new AzureAccount { Id = "*****@*****.**", Type = AzureAccount.AccountType.User }; account.SetProperty(AzureAccount.Property.Tenants, tenantId.ToString()); account.SetProperty(AzureAccount.Property.Subscriptions, subscriptionId.ToString()); var subscription = new AzureSubscription() { Id = subscriptionId, Name = "Test Subscription 1", Environment = EnvironmentName.AzureCloud, Account = account.Id, }; subscription.SetProperty(AzureSubscription.Property.Tenants, tenantId.ToString()); subscription.SetProperty(AzureSubscription.Property.StorageAccount, storageAccount); client.AddOrSetAccount(account); client.AddOrSetSubscription(subscription); client.SetSubscriptionAsDefault(subscriptionId, account.Id); return profile; }
public void RemovesAzureEnvironment() { var commandRuntimeMock = new Mock<ICommandRuntime>(); commandRuntimeMock.Setup(f => f.ShouldProcess(It.IsAny<string>(), It.IsAny<string>())).Returns(true); const string name = "test"; var profile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)); AzureSMCmdlet.CurrentProfile = profile; ProfileClient client = new ProfileClient(profile); client.AddOrSetEnvironment(new AzureEnvironment { Name = name }); client.Profile.Save(); var cmdlet = new RemoveAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Force = true, Name = name }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); client = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile))); Assert.False(client.Profile.Environments.ContainsKey(name)); }
public void RestartsWebsiteSlot() { // Setup const string websiteName = "website1"; const string slot = "staging"; Mock<IWebsitesClient> websitesClientMock = new Mock<IWebsitesClient>(); websitesClientMock.Setup(f => f.RestartWebsite(websiteName, slot)); // Test RestartAzureWebsiteCommand restartAzureWebsiteCommand = new RestartAzureWebsiteCommand() { CommandRuntime = new MockCommandRuntime(), Name = websiteName, WebsitesClient = websitesClientMock.Object, Slot = slot }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription{Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; restartAzureWebsiteCommand.ExecuteCmdlet(); websitesClientMock.Verify(f => f.RestartWebsite(websiteName, slot), Times.Once()); }
/// <summary> /// Creates new WebsitesClient /// </summary> /// <param name="subscription">Subscription containing websites to manipulate</param> /// <param name="logger">The logger action</param> public WebsitesClient(AzureSMProfile profile, AzureSubscription subscription, Action<string> logger) { Logger = logger; cloudServiceClient = new CloudServiceClient(profile, subscription, debugStream: logger); WebsiteManagementClient = AzureSession.ClientFactory.CreateClient<WebSiteManagementClient>(profile, subscription, AzureEnvironment.Endpoint.ServiceManagement); this.subscription = subscription; }
public void ClearAzureProfileClearsDefaultProfile() { ClearAzureProfileCommand cmdlt = new ClearAzureProfileCommand(); // Setup var profile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)); AzureSMCmdlet.CurrentProfile = profile; ProfileClient client = new ProfileClient(profile); client.AddOrSetAccount(azureAccount); client.AddOrSetEnvironment(azureEnvironment); client.AddOrSetSubscription(azureSubscription1); client.Profile.Save(); cmdlt.CommandRuntime = commandRuntimeMock; cmdlt.Force = new SwitchParameter(true); // Act cmdlt.InvokeBeginProcessing(); cmdlt.ExecuteCmdlet(); cmdlt.InvokeEndProcessing(); // Verify client = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile))); Assert.Equal(0, client.Profile.Subscriptions.Count); Assert.Equal(0, client.Profile.Accounts.Count); Assert.Equal(2, client.Profile.Environments.Count); //only default environments }
public bool Deserialize(string contents, AzureSMProfile profile) { ProfileData data; Debug.Assert(profile != null); DeserializeErrors = new List<string>(); DataContractSerializer serializer = new DataContractSerializer(typeof(ProfileData)); using (MemoryStream s = new MemoryStream(Encoding.UTF8.GetBytes(contents ?? ""))) { data = (ProfileData)serializer.ReadObject(s); } if (data != null) { foreach (AzureEnvironmentData oldEnv in data.Environments) { profile.Environments[oldEnv.Name] = oldEnv.ToAzureEnvironment(); } List<AzureEnvironment> envs = profile.Environments.Values.ToList(); foreach (AzureSubscriptionData oldSubscription in data.Subscriptions) { try { var newSubscription = oldSubscription.ToAzureSubscription(envs); if (newSubscription.Account == null) { continue; } var newAccounts = oldSubscription.ToAzureAccounts(); foreach (var account in newAccounts) { if (profile.Accounts.ContainsKey(account.Id)) { profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Tenants, account.GetPropertyAsArray(AzureAccount.Property.Tenants)); profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Subscriptions, account.GetPropertyAsArray(AzureAccount.Property.Subscriptions)); } else { profile.Accounts[account.Id] = account; } } profile.Subscriptions[newSubscription.Id] = newSubscription; } catch (Exception ex) { // Skip subscription if failed to load DeserializeErrors.Add(ex.Message); } } } return DeserializeErrors.Count == 0; }
public string Serialize(AzureSMProfile profile) { return(JsonConvert.SerializeObject(new { Environments = profile.Environments.Values.ToList(), Subscriptions = profile.Subscriptions.Values.ToList(), Accounts = profile.Accounts.Values.ToList() }, Formatting.Indented)); }
public string Serialize(AzureSMProfile profile) { return JsonConvert.SerializeObject(new { Environments = profile.Environments.Values.ToList(), Subscriptions = profile.Subscriptions.Values.ToList(), Accounts = profile.Accounts.Values.ToList() }, Formatting.Indented); }
/// <summary> /// Initializes a new instance of the <see cref="ServerDataServiceCertAuth"/> class /// </summary> /// <param name="subscription">The subscription used to connect and authenticate.</param> /// <param name="serverName">The name of the server to connect to.</param> private ServerDataServiceCertAuth( AzureSMProfile profile, AzureSubscription subscription, string serverName) { this.profile = profile; this.serverName = serverName; this.subscription = subscription; }
public void NewProfileFromCertificateWithNullsThrowsArgumentNullException() { MemoryDataStore dataStore = new MemoryDataStore(); AzureSession.DataStore = dataStore; AzureSMProfile newProfile = new AzureSMProfile(); ProfileClient client1 = new ProfileClient(newProfile); Assert.Throws<ArgumentNullException>(() => client1.InitializeProfile(null, Guid.NewGuid(), new X509Certificate2(), "foo")); Assert.Throws<ArgumentNullException>(() => client1.InitializeProfile(AzureEnvironment.PublicEnvironments["AzureCloud"], Guid.NewGuid(), null, "foo")); }
public void ProfileMigratesOldData() { MemoryDataStore dataStore = new MemoryDataStore(); dataStore.VirtualStore[oldProfileDataPath] = oldProfileData; AzureSession.DataStore = dataStore; currentProfile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)); ProfileClient client = new ProfileClient(currentProfile); Assert.False(dataStore.FileExists(oldProfileDataPath)); Assert.True(dataStore.FileExists(newProfileDataPath)); }
public void GetAzureWebsiteDeploymentTest() { // Setup var clientMock = new Mock<IWebsitesClient>(); var site1 = new Site { Name = "website1", WebSpace = "webspace1", SiteProperties = new SiteProperties { Properties = new List<NameValuePair> { new NameValuePair {Name = "repositoryuri", Value = "http"}, new NameValuePair {Name = "PublishingUsername", Value = "user1"}, new NameValuePair {Name = "PublishingPassword", Value = "password1"} } } }; clientMock.Setup(c => c.GetWebsite("website1", null)) .Returns(site1); clientMock.Setup(c => c.ListWebSpaces()) .Returns(new[] { new WebSpace { Name = "webspace1" }, new WebSpace { Name = "webspace2" } }); clientMock.Setup(c => c.ListSitesInWebSpace("webspace1")) .Returns(new[] { site1 }); clientMock.Setup(c => c.ListSitesInWebSpace("webspace2")) .Returns(new[] { new Site { Name = "website2", WebSpace = "webspace2" } }); SimpleDeploymentServiceManagement deploymentChannel = new SimpleDeploymentServiceManagement(); deploymentChannel.GetDeploymentsThunk = ar => new List<DeployResult> { new DeployResult(), new DeployResult() }; // Test GetAzureWebsiteDeploymentCommand getAzureWebsiteDeploymentCommand = new GetAzureWebsiteDeploymentCommand(deploymentChannel) { Name = "website1", ShareChannel = true, WebsitesClient = clientMock.Object, CommandRuntime = new MockCommandRuntime(), }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription{Id = new Guid(subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(subscriptionId)] = subscription; getAzureWebsiteDeploymentCommand.ExecuteCmdlet(); var deployments = System.Management.Automation.LanguagePrimitives.GetEnumerable(((MockCommandRuntime)getAzureWebsiteDeploymentCommand.CommandRuntime).OutputPipeline).Cast<DeployResult>(); Assert.NotNull(deployments); Assert.Equal(2, deployments.Count()); }
public StorSimpleClient(AzureSMProfile AzureSMProfile, AzureSubscription currentSubscription) { // Temp code to be able to test internal env. ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };//IgnoreCertificateErrorHandler;//delegate { return true; }; this.Profile = AzureSMProfile; this.cloudServicesClient = AzureSession.ClientFactory.CreateClient<CloudServiceManagementClient>(AzureSMProfile, currentSubscription, AzureEnvironment.Endpoint.ServiceManagement); ResourceCachetimeoutPolicy.AbsoluteExpiration = DateTimeOffset.Now.AddHours(1.0d); }
public PSAzureSubscription(AzureSubscription subscription, AzureSMProfile profile) { SubscriptionId = subscription.Id.ToString(); SubscriptionName = subscription.Name; Environment = subscription.Environment; DefaultAccount = subscription.Account; Accounts = profile.Accounts.Values.Where(a => a.HasSubscription(subscription.Id)).ToArray(); IsDefault = subscription.IsPropertySet(AzureSubscription.Property.Default); IsCurrent = profile.Context != null && profile.Context.Subscription.Id == subscription.Id; CurrentStorageAccountName = subscription.GetProperty(AzureSubscription.Property.StorageAccount); TenantId = subscription.GetPropertyAsArray(AzureSubscription.Property.Tenants).FirstOrDefault(); }
public bool Deserialize(string contents, AzureSMProfile profile) { DeserializeErrors = new List<string>(); try { var jsonProfile = JObject.Parse(contents); foreach (var env in jsonProfile["Environments"]) { try { profile.Environments[(string) env["Name"]] = JsonConvert.DeserializeObject<AzureEnvironment>(env.ToString()); } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } } foreach (var subscription in jsonProfile["Subscriptions"]) { try { profile.Subscriptions[new Guid((string) subscription["Id"])] = JsonConvert.DeserializeObject<AzureSubscription>(subscription.ToString()); } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } } foreach (var account in jsonProfile["Accounts"]) { try { profile.Accounts[(string) account["Id"]] = JsonConvert.DeserializeObject<AzureAccount>(account.ToString()); } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } } } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } return DeserializeErrors.Count == 0; }
public bool Deserialize(string contents, AzureSMProfile profile) { DeserializeErrors = new List <string>(); try { var jsonProfile = JObject.Parse(contents); foreach (var env in jsonProfile["Environments"]) { try { profile.Environments[(string)env["Name"]] = JsonConvert.DeserializeObject <AzureEnvironment>(env.ToString()); } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } } foreach (var subscription in jsonProfile["Subscriptions"]) { try { profile.Subscriptions[new Guid((string)subscription["Id"])] = JsonConvert.DeserializeObject <AzureSubscription>(subscription.ToString()); } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } } foreach (var account in jsonProfile["Accounts"]) { try { profile.Accounts[(string)account["Id"]] = JsonConvert.DeserializeObject <AzureAccount>(account.ToString()); } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } } } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } return(DeserializeErrors.Count == 0); }
public void Apply <TClient>(TClient client, AzureSMProfile profile, AzureEnvironment.Endpoint endpoint) where TClient : ServiceClient <TClient> { Debug.Assert(ClientFactory != null); if (endpoint == AzureEnvironment.Endpoint.ServiceManagement) { RegisterServiceManagementProviders <TClient>(profile); } else if (endpoint == AzureEnvironment.Endpoint.ResourceManager) { RegisterResourceManagerProviders <TClient>(profile); } }
protected void SetupProfile(string storageName) { currentProfile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)); AzureSMCmdlet.CurrentProfile = currentProfile; var subscription = new AzureSubscription { Id = new Guid(subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(subscriptionId)] = subscription; if (storageName != null) { currentProfile.Context.Subscription.Properties[AzureSubscription.Property.StorageAccount] = storageName; } currentProfile.Save(); }
public void GetWebsiteMetricsBasicTest() { // Setup var clientMock = new Mock<IWebsitesClient>(); clientMock.Setup(c => c.ListWebSpaces()) .Returns(new[] {new WebSpace {Name = "webspace1"}, new WebSpace {Name = "webspace2"}}); clientMock.Setup(c => c.ListSitesInWebSpace("webspace1")) .Returns(new[] {new Site {Name = "website1", WebSpace = "webspace1"}}); clientMock.Setup(c => c.GetHistoricalUsageMetrics("website1", null, null, null, null, null, false, false)) .Returns(new[] {new MetricResponse() {Code = "Success", Data = new MetricSet() { Name = "CPU Time", StartTime = DateTime.Parse("7/28/2014 1:00:00 AM", new CultureInfo("en-US")), EndTime = DateTime.Parse("7/28/2014 2:00:00 AM", new CultureInfo("en-US")), Values = new List<MetricSample> { new MetricSample { TimeCreated = DateTime.Parse("7/28/2014 1:00:00 AM", new CultureInfo("en-US")), Total = 201, } } }}}); // Test var command = new GetAzureWebsiteMetricCommand { Name = "website1", CommandRuntime = new MockCommandRuntime(), WebsitesClient = clientMock.Object }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription { Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; command.ExecuteCmdlet(); Assert.Equal(1, ((MockCommandRuntime)command.CommandRuntime).OutputPipeline.Count); var metrics = (MetricResponse)((MockCommandRuntime)command.CommandRuntime).OutputPipeline.FirstOrDefault(); Assert.NotNull(metrics); Assert.Equal("CPU Time", metrics.Data.Name); Assert.NotNull(metrics.Data.Values); Assert.NotNull(metrics.Data.Values[0]); Assert.Equal(201, metrics.Data.Values[0].Total); }
public void ProcessGetMediaServicesTest() { // Setup Mock<IMediaServicesClient> clientMock = new Mock<IMediaServicesClient>(); Guid id1 = Guid.NewGuid(); Guid id2 = Guid.NewGuid(); MediaServicesAccountListResponse response = new MediaServicesAccountListResponse(); response.Accounts.Add(new MediaServicesAccountListResponse.MediaServiceAccount { AccountId = id1.ToString(), Name = "WAMS Account 1" }); response.Accounts.Add(new MediaServicesAccountListResponse.MediaServiceAccount { AccountId = id2.ToString(), Name = "WAMS Account 2" }); clientMock.Setup(f => f.GetMediaServiceAccountsAsync()).Returns(Task.Factory.StartNew(() => response)); // Test GetAzureMediaServiceCommand getAzureMediaServiceCommand = new GetAzureMediaServiceCommand { CommandRuntime = new MockCommandRuntime(), MediaServicesClient = clientMock.Object, }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription { Id = new Guid(SubscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(SubscriptionId)] = subscription; getAzureMediaServiceCommand.ExecuteCmdlet(); IEnumerable<MediaServiceAccount> accounts = System.Management.Automation.LanguagePrimitives.GetEnumerable(((MockCommandRuntime)getAzureMediaServiceCommand.CommandRuntime).OutputPipeline).Cast<MediaServiceAccount>(); Assert.NotNull(accounts); Assert.Equal(2, accounts.Count()); Assert.True(accounts.Any(mediaservice => (mediaservice).AccountId == id1)); Assert.True(accounts.Any(mediaservice => (mediaservice).AccountId == id2)); Assert.True(accounts.Any(mediaservice => (mediaservice).Name.Equals("WAMS Account 1"))); Assert.True(accounts.Any(mediaservice => (mediaservice).Name.Equals("WAMS Account 2"))); }
public void UpdatesRemote() { // Setup var mockClient = new Mock<IWebsitesClient>(); string slot = WebsiteSlotName.Staging.ToString(); SiteProperties props = new SiteProperties() { Properties = new List<NameValuePair>() { new NameValuePair() { Name = "RepositoryUri", Value = "https://[email protected]:443/website.git" }, new NameValuePair() { Name = "PublishingUsername", Value = "test" } } }; mockClient.Setup(c => c.GetWebsiteSlots("website1")) .Returns( new List<Site> { new Site { Name = "website1", WebSpace = "webspace1", SiteProperties = props }, new Site { Name = "website1(staging)", WebSpace = "webspace1", SiteProperties = props } }); mockClient.Setup(c => c.GetSlotName("website1")) .Returns(WebsiteSlotName.Production.ToString()) .Verifiable(); mockClient.Setup(c => c.GetSlotName("website1(staging)")) .Returns(WebsiteSlotName.Staging.ToString()) .Verifiable(); // Test UpdateAzureWebsiteRepositoryCommand cmdlet = new UpdateAzureWebsiteRepositoryCommand { CommandRuntime = new MockCommandRuntime(), WebsitesClient = mockClient.Object, Name = "website1", }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription{Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; // Switch existing website cmdlet.ExecuteCmdlet(); mockClient.Verify(c => c.GetSlotName("website1(staging)"), Times.Once()); mockClient.Verify(c => c.GetSlotName("website1"), Times.Once()); }
private void UpdateSubscriptionRegisteredProviders(AzureSMProfile profile, AzureSubscription subscription, List <string> providers) { if (providers != null && providers.Count > 0) { subscription.SetOrAppendProperty(AzureSubscription.Property.RegisteredResourceProviders, providers.ToArray()); try { ProfileClient profileClient = new ProfileClient(profile); profileClient.AddOrSetSubscription(subscription); profileClient.Profile.Save(); } catch (KeyNotFoundException) { // if using a subscription data file, do not write registration to disk // long term solution is using -Profile parameter } } }
public EnvironmentSetupHelper() { var datastore = new MemoryDataStore(); AzureSession.DataStore = datastore; var profile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)); var rmprofile = new AzureRMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)); rmprofile.Environments.Add("foo", AzureEnvironment.PublicEnvironments.Values.FirstOrDefault()); rmprofile.Context = new AzureContext(new AzureSubscription(), new AzureAccount(), rmprofile.Environments["foo"], new AzureTenant()); rmprofile.Context.Subscription.Environment = "foo"; if (AzureRmProfileProvider.Instance.Profile == null) { AzureRmProfileProvider.Instance.Profile = rmprofile; } AzureSession.DataStore = datastore; ProfileClient = new ProfileClient(profile); // Ignore SSL errors System.Net.ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) => true; // Set RunningMocked TestMockSupport.RunningMocked = HttpMockServer.GetCurrentMode() == HttpRecorderMode.Playback; }
public EnvironmentSetupHelper() { var datastore = new MemoryDataStore(); AzureSession.DataStore = datastore; var profile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)); AzureSMCmdlet.CurrentProfile = profile; AzureSession.DataStore = datastore; ProfileClient = new ProfileClient(profile); // Ignore SSL errors System.Net.ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) => true; // Set RunningMocked if (HttpMockServer.GetCurrentMode() == HttpRecorderMode.Playback) { TestMockSupport.RunningMocked = true; } else { TestMockSupport.RunningMocked = false; } }
/// <summary> /// Registers resource providers for RDFE. /// </summary> /// <typeparam name="T">The client type</typeparam> private void RegisterServiceManagementProviders <T>(AzureSMProfile profile) { var credentials = AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(profile.Context); var providersToRegister = RequiredResourceLookup.RequiredProvidersForServiceManagement <T>(); var registeredProviders = profile.Context.Subscription.GetPropertyAsArray(AzureSubscription.Property.RegisteredResourceProviders); var unregisteredProviders = providersToRegister.Where(p => !registeredProviders.Contains(p)).ToList(); var successfullyRegisteredProvider = new List <string>(); if (unregisteredProviders.Count > 0) { using (var client = new ManagementClient( credentials, profile.Context.Environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ServiceManagement))) { foreach (var provider in unregisteredProviders) { try { client.Subscriptions.RegisterResource(provider); } catch (CloudException ex) { if (ex.Response.StatusCode != HttpStatusCode.Conflict && ex.Response.StatusCode != HttpStatusCode.NotFound) { // Conflict means already registered, that's OK. // NotFound means there is no registration support, like Windows Azure Pack. // Otherwise it's a failure. throw; } } successfullyRegisteredProvider.Add(provider); } } Debug.Assert(profile is AzureSMProfile); UpdateSubscriptionRegisteredProviders((AzureSMProfile)profile, profile.Context.Subscription, successfullyRegisteredProvider); } }
public static IHDInsightSubscriptionCredentials GetSubscriptionCredentials( this IAzureHDInsightCommonCommandBase command, AzureSubscription currentSubscription, AzureEnvironment environment, AzureSMProfile profile) { var accountId = currentSubscription.Account; Debug.Assert(profile.Accounts.ContainsKey(accountId)); if (profile.Accounts[accountId].Type == AzureAccount.AccountType.Certificate) { return GetSubscriptionCertificateCredentials(command, currentSubscription, profile.Accounts[accountId], environment); } else if (profile.Accounts[accountId].Type == AzureAccount.AccountType.User) { return GetAccessTokenCredentials(command, currentSubscription, profile.Accounts[accountId], environment); } else if (profile.Accounts[accountId].Type == AzureAccount.AccountType.ServicePrincipal) { return GetAccessTokenCredentials(command, currentSubscription, profile.Accounts[accountId], environment); } throw new NotSupportedException(); }
/// <summary> /// Creates new Scheduler Management Convenience Client /// </summary> /// <param name="subscription">Subscription containing websites to manipulate</param> public SchedulerMgmntClient(AzureSMProfile profile, AzureSubscription subscription) { currentSubscription = subscription; csmClient = AzureSession.ClientFactory.CreateClient<CloudServiceManagementClient>(profile, subscription, AzureEnvironment.Endpoint.ServiceManagement); schedulerManagementClient = AzureSession.ClientFactory.CreateClient<SchedulerManagementClient>(profile, subscription, AzureEnvironment.Endpoint.ServiceManagement); //Get RP properties IDictionary<string, string> dict = schedulerManagementClient.GetResourceProviderProperties().Properties; //Get available regions string val = string.Empty; if (dict.TryGetValue(SupportedRegionsKey, out val)) { AvailableRegions = new List<string>(); val.Split(',').ToList().ForEach(s => AvailableRegions.Add(s)); } //Store global counts for max jobs and min recurrence for each plan if (dict.TryGetValue(FreeMaxJobCountKey, out val)) FreeMaxJobCountValue = Convert.ToInt32(dict[FreeMaxJobCountKey]); if (dict.TryGetValue(FreeMinRecurrenceKey, out val)) FreeMinRecurrenceValue = TimeSpan.Parse(dict[FreeMinRecurrenceKey]); if (dict.TryGetValue(StandardMaxJobCountKey, out val)) StandardMaxJobCountValue = Convert.ToInt32(dict[StandardMaxJobCountKey]); if (dict.TryGetValue(StandardMinRecurrenceKey, out val)) StandardMinRecurrenceValue = TimeSpan.Parse(dict[StandardMinRecurrenceKey]); if (dict.TryGetValue(PremiumMaxJobCountKey, out val)) PremiumMaxJobCountValue = Convert.ToInt32(dict[PremiumMaxJobCountKey]); if (dict.TryGetValue(PremiumMinRecurrenceKey, out val)) PremiumMinRecurrenceValue = TimeSpan.Parse(dict[PremiumMinRecurrenceKey]); }
public void ProcessStartWebsiteTest() { const string websiteName = "website1"; // Setup Mock<IWebsitesClient> websitesClientMock = new Mock<IWebsitesClient>(); websitesClientMock.Setup(f => f.StartWebsite(websiteName, null)); // Test StartAzureWebsiteCommand startAzureWebsiteCommand = new StartAzureWebsiteCommand() { CommandRuntime = new MockCommandRuntime(), Name = websiteName, WebsitesClient = websitesClientMock.Object }; currentProfile = new AzureSMProfile(); var subscription = new AzureSubscription{Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; startAzureWebsiteCommand.ExecuteCmdlet(); websitesClientMock.Verify(f => f.StartWebsite(websiteName, null), Times.Once()); }
public bool Deserialize(string contents, AzureSMProfile profile) { ProfileData data; Debug.Assert(profile != null); DeserializeErrors = new List <string>(); DataContractSerializer serializer = new DataContractSerializer(typeof(ProfileData)); using (MemoryStream s = new MemoryStream(Encoding.UTF8.GetBytes(contents ?? ""))) { data = (ProfileData)serializer.ReadObject(s); } if (data != null) { foreach (AzureEnvironmentData oldEnv in data.Environments) { profile.Environments[oldEnv.Name] = oldEnv.ToAzureEnvironment(); } List <AzureEnvironment> envs = profile.Environments.Values.ToList(); foreach (AzureSubscriptionData oldSubscription in data.Subscriptions) { try { var newSubscription = oldSubscription.ToAzureSubscription(envs); if (newSubscription.Account == null) { continue; } var newAccounts = oldSubscription.ToAzureAccounts(); foreach (var account in newAccounts) { if (profile.Accounts.ContainsKey(account.Id)) { profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Tenants, account.GetPropertyAsArray(AzureAccount.Property.Tenants)); profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Subscriptions, account.GetPropertyAsArray(AzureAccount.Property.Subscriptions)); } else { profile.Accounts[account.Id] = account; } } profile.Subscriptions[newSubscription.Id] = newSubscription; } catch (Exception ex) { // Skip subscription if failed to load DeserializeErrors.Add(ex.Message); } } } return(DeserializeErrors.Count == 0); }
public string Serialize(AzureSMProfile obj) { // We do not use the serialize for xml serializer anymore and rely solely on the JSON serializer. throw new NotImplementedException(); }