ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-02-16 10:58:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

Unit tests for Azure scenarios (#495)

Browse Source 
* Test firewall rule handling is able to process through the service layer

* Additional tests for authentication and the resource wrapper code

* Positive test case for CreateFirewallRule

* Fixed copyright and usings
This commit is contained in:
Kevin Cunnane
2017-10-12 17:23:34 -07:00
committed by GitHub
parent 14e3b3a3f6
commit b416951414
14 changed files with 536 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Microsoft.SqlTools.ResourceProvider.Core/Firewall/FirewallRuleService.cs
View File

@@ -158,7 +158,7 @@ namespace Microsoft.SqlTools.ResourceProvider.Core.Firewall
if (subscriptions == null)
{
throw new FirewallRuleException(SR.FirewallRuleCreationFailed);
throw new FirewallRuleException(SR.NoSubscriptionsFound);
}
ServiceResponse<FirewallRuleResource> response = await AzureUtil.ExecuteGetAzureResourceAsParallel((object)null,

11
src/Microsoft.SqlTools.ResourceProvider.Core/Localization/sr.cs
View File

@@ -29,6 +29,14 @@ namespace Microsoft.SqlTools.ResourceProvider.Core
}
public static string NoSubscriptionsFound
{
get
{
return Keys.GetString(Keys.NoSubscriptionsFound);
}
}
public static string AzureServerNotFound
{
get
@@ -117,6 +125,9 @@ namespace Microsoft.SqlTools.ResourceProvider.Core
static CultureInfo _culture = null;
public const string NoSubscriptionsFound = "NoSubscriptionsFound";
public const string AzureServerNotFound = "AzureServerNotFound";

4
src/Microsoft.SqlTools.ResourceProvider.Core/Localization/sr.resx
View File

@@ -117,6 +117,10 @@
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="NoSubscriptionsFound" xml:space="preserve">
<value>No subscriptions were found for the currently logged in user account.</value>
<comment></comment>
</data>
<data name="AzureServerNotFound" xml:space="preserve">
<value>The server you specified {0} does not exist in any subscription in {1}. Either you have signed in with an incorrect account or your server was removed from subscription(s) in this account. Please check your account and try again.</value>
<comment></comment>

1
src/Microsoft.SqlTools.ResourceProvider.Core/Localization/sr.strings
View File

@@ -22,6 +22,7 @@
############################################################################
# Azure Core DLL
NoSubscriptionsFound = No subscriptions were found for the currently logged in user account.
AzureServerNotFound = The server you specified {0} does not exist in any subscription in {1}. Either you have signed in with an incorrect account or your server was removed from subscription(s) in this account. Please check your account and try again.
AzureSubscriptionFailedErrorMessage = An error occurred while getting Azure subscriptions
DatabaseDiscoveryFailedErrorMessage = An error occurred while getting databases from servers of type {0} from {1}

5
src/Microsoft.SqlTools.ResourceProvider.Core/Localization/sr.xlf
View File

@@ -52,6 +52,11 @@
<target state="new">An error occurred while creating a new firewall rule: '{0}'</target>
<note></note>
</trans-unit>
<trans-unit id="NoSubscriptionsFound">
<source>No subscriptions were found for the currently logged in user account.</source>
<target state="new">No subscriptions were found for the currently logged in user account.</target>
<note></note>
</trans-unit>
</body>
</file>
</xliff>

21
src/Microsoft.SqlTools.ResourceProvider.DefaultImpl/AzureAuthenticationManager.cs
View File

@@ -27,7 +27,7 @@ namespace Microsoft.SqlTools.ResourceProvider.DefaultImpl
"Microsoft.SqlTools.ResourceProvider.DefaultImpl.AzureAuthenticationManager",
1)
]
class AzureAuthenticationManager : ExportableBase, IAzureAuthenticationManager
public class AzureAuthenticationManager : ExportableBase, IAzureAuthenticationManager
{
private Dictionary<string, AzureUserAccount> accountsMap;
private string currentAccountId = null;
@@ -88,12 +88,23 @@ namespace Microsoft.SqlTools.ResourceProvider.DefaultImpl
public AzureUserAccount CreateUserAccount(AccountTokenWrapper accountTokenWrapper)
{
Account account = accountTokenWrapper.Account;
CommonUtil.CheckForNull(accountTokenWrapper.Account, nameof(account));
CommonUtil.CheckForNull(accountTokenWrapper, nameof(accountTokenWrapper));
CommonUtil.CheckForNull(account, nameof(account));
CommonUtil.CheckForNull(account.Key, nameof(account) + ".Key");
CommonUtil.CheckForNull(accountTokenWrapper.SecurityTokenMappings, nameof(account) + ".SecurityTokenMappings");
AzureUserAccount userAccount = new AzureUserAccount();
userAccount.UniqueId = account.Key.AccountId;
userAccount.DisplayInfo = ToDisplayInfo(account);
userAccount.NeedsReauthentication = account.IsStale;
userAccount.AllTenants = ProcessTenants(accountTokenWrapper, account);
return userAccount;
}
private static IList<IAzureTenant> ProcessTenants(AccountTokenWrapper accountTokenWrapper, Account account)
{
IList<IAzureTenant> tenants = new List<IAzureTenant>();
if (account.Properties != null && account.Properties.Tenants != null)
{
foreach (Tenant tenant in account.Properties.Tenants)
{
AccountSecurityToken token;
@@ -111,15 +122,15 @@ namespace Microsoft.SqlTools.ResourceProvider.DefaultImpl
}
// else ignore for now as we can't handle a request to get a tenant without an access key
}
userAccount.AllTenants = tenants;
return userAccount;
}
return tenants;
}
private AzureUserAccountDisplayInfo ToDisplayInfo(Account account)
{
return new AzureUserAccountDisplayInfo()
{
AccountDisplayName = account.DisplayInfo.DisplayName,
AccountDisplayName = account.DisplayInfo != null ? account.DisplayInfo.DisplayName : account.Key.AccountId,
ProviderDisplayName = account.Key.ProviderId
};
}

1
src/Microsoft.SqlTools.ResourceProvider.DefaultImpl/AzureResourceManager.cs
View File

@@ -20,7 +20,6 @@ using Microsoft.Rest;
using System.Globalization;
using Microsoft.Rest.Azure;
using Microsoft.SqlTools.ResourceProvider.Core;
using System.Collections;
using System.Threading;
namespace Microsoft.SqlTools.ResourceProvider.DefaultImpl

2
src/Microsoft.SqlTools.ResourceProvider.DefaultImpl/AzureResourceWrapper.cs
View File

@@ -81,7 +81,7 @@ namespace Microsoft.SqlTools.ResourceProvider.DefaultImpl
{
this.resourceGroupName = ParseResourceGroupNameFromId();
}
return this.resourceGroupName;
return this.resourceGroupName ?? string.Empty;
}
set
{

113
test/Microsoft.SqlTools.ServiceLayer.UnitTests/ResourceProvider/Azure/AzureAuthenticationManagerTest.cs Normal file
View File

@@ -0,0 +1,113 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.SqlTools.Extensibility;
using Microsoft.SqlTools.ResourceProvider.Core;
using Microsoft.SqlTools.ResourceProvider.Core.Authentication;
using Microsoft.SqlTools.ResourceProvider.Core.Contracts;
using Microsoft.SqlTools.ResourceProvider.DefaultImpl;
using Moq;
using Xunit;
namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ResourceProvider.Azure
{
public class AzureAuthenticationManagerTest
{
private Mock<IAzureResourceManager> resourceManagerMock;
private RegisteredServiceProvider serviceProvider;
public AzureAuthenticationManagerTest()
{
resourceManagerMock = new Mock<IAzureResourceManager>();
serviceProvider = new RegisteredServiceProvider();
serviceProvider.RegisterSingleService<IAzureResourceManager>(resourceManagerMock.Object);
}
[Fact]
public async Task CurrentUserShouldBeNullWhenUserIsNotSignedIn()
{
IAzureAuthenticationManager accountManager = await CreateAccountManager(null, null);
Assert.Null(await accountManager.GetCurrentAccountAsync());
}
[Fact]
public async Task GetSubscriptionShouldReturnEmptyWhenUserIsNotSignedIn()
{
IAzureAuthenticationManager accountManager = await CreateAccountManager(null, null);
IEnumerable<IAzureUserAccountSubscriptionContext> result =
await accountManager.GetSelectedSubscriptionsAsync();
Assert.False(result.Any());
}
[Fact]
public async Task GetSubscriptionShouldThrowWhenUserNeedsAuthentication()
{
var currentUserAccount = CreateAccount();
currentUserAccount.Account.IsStale = true;
IAzureAuthenticationManager accountManager = await CreateAccountManager(currentUserAccount, null);
await Assert.ThrowsAsync<UserNeedsAuthenticationException>(() => accountManager.GetSelectedSubscriptionsAsync());
}
[Fact]
public async Task GetSubscriptionShouldThrowIfFailed()
{
var currentUserAccount = CreateAccount();
IAzureAuthenticationManager accountManager = await CreateAccountManager(currentUserAccount, null, true);
await Assert.ThrowsAsync<ServiceFailedException>(() => accountManager.GetSelectedSubscriptionsAsync());
}
[Fact]
public async Task GetSubscriptionShouldReturnTheListSuccessfully()
{
List<IAzureUserAccountSubscriptionContext> subscriptions = new List<IAzureUserAccountSubscriptionContext> {
new Mock<IAzureUserAccountSubscriptionContext>().Object
};
var currentUserAccount = CreateAccount();
IAzureAuthenticationManager accountManager = await CreateAccountManager(currentUserAccount, subscriptions, false);
IEnumerable<IAzureUserAccountSubscriptionContext> result =
await accountManager.GetSelectedSubscriptionsAsync();
Assert.True(result.Any());
}
private AccountTokenWrapper CreateAccount(bool needsReauthentication = false)
{
return new AccountTokenWrapper(new Account()
{
Key = new AccountKey()
{
AccountId = "MyAccount",
ProviderId = "MSSQL"
},
IsStale = needsReauthentication
},
new Dictionary<string, AccountSecurityToken>());
}
private async Task<AzureAuthenticationManager> CreateAccountManager(AccountTokenWrapper currentAccount,
IEnumerable<IAzureUserAccountSubscriptionContext> subscriptions, bool shouldFail = false)
{
AzureAuthenticationManager azureAuthenticationManager = new AzureAuthenticationManager();
azureAuthenticationManager.SetServiceProvider(serviceProvider);
if (currentAccount != null)
{
await azureAuthenticationManager.SetCurrentAccountAsync(currentAccount);
}
if (!shouldFail)
{
resourceManagerMock.Setup(x => x.GetSubscriptionContextsAsync(It.IsAny<IAzureUserAccount>())).Returns(Task.FromResult(subscriptions));
}
else
{
resourceManagerMock.Setup(x => x.GetSubscriptionContextsAsync(It.IsAny<IAzureUserAccount>())).Throws(new Exception());
}
return azureAuthenticationManager;
}
}
}

53
test/Microsoft.SqlTools.ServiceLayer.UnitTests/ResourceProvider/Azure/AzureResourceWrapperTest.cs Normal file
View File

@@ -0,0 +1,53 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.Azure.Management.Sql.Models;
using Microsoft.SqlTools.ResourceProvider.DefaultImpl;
using Xunit;
namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ResourceProvider.Azure
{
public class AzureResourceWrapperTest
{
[Fact]
public void ShouldParseResourceGroupFromId()
{
// Given a resource with a known resource group
TrackedResource trackedResource = CreateMockResource(
"/subscriptions/aaaaaaaa-1234-cccc-dddd-a1234v12c23/resourceGroups/myresourcegroup/providers/Microsoft.Sql/servers/my-server",
"my-server",
"Microsoft.Sql");
// When I get the resource group name
AzureResourceWrapper resource = new AzureResourceWrapper(trackedResource);
string rgName = resource.ResourceGroupName;
// then I get it as expected
Assert.Equal("myresourcegroup", rgName);
}
[Fact]
public void ShouldHandleMissingResourceGroup()
{
// Given a resource without resource group in the ID
TrackedResource trackedResource = CreateMockResource(
"/subscriptions/aaaaaaaa-1234-cccc-dddd-a1234v12c23",
"my-server",
"Microsoft.Sql");
// When I get the resource group name
AzureResourceWrapper resource = new AzureResourceWrapper(trackedResource);
string rgName = resource.ResourceGroupName;
// then I get string.Empty
Assert.Equal(string.Empty, rgName);
}
private TrackedResource CreateMockResource(string id = null, string name = null, string type = null)
{
return new TrackedResource("Somewhere", id, name, type);
}
}
}

2
test/Microsoft.SqlTools.ServiceLayer.UnitTests/ResourceProvider/Azure/AzureSqlServerDiscoveryProviderTest.cs
View File

@@ -45,7 +45,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ResourceProvider.Azure
}
[Fact]
public async Task GetShouldReturnEmptyGivenNotSubscriptionFound()
public async Task GetShouldReturnEmptyGivenNoSubscriptionFound()
{
Dictionary<string, List<string>> subscriptionToDatabaseMap = new Dictionary<string, List<string>>();

206
test/Microsoft.SqlTools.ServiceLayer.UnitTests/ResourceProvider/ResourceProviderServiceTests.cs
View File

@@ -3,17 +3,30 @@
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlTools.Hosting.Protocol;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.SqlTools.Extensibility;
using Microsoft.SqlTools.ResourceProvider.Core;
using Moq;
using Microsoft.SqlTools.Hosting.Protocol;
using Microsoft.SqlTools.ResourceProvider;
using Microsoft.SqlTools.ResourceProvider.Core;
using Microsoft.SqlTools.ResourceProvider.Core.Authentication;
using Microsoft.SqlTools.ResourceProvider.Core.Contracts;
using Microsoft.SqlTools.ResourceProvider.Core.Firewall;
using Microsoft.SqlTools.ResourceProvider.DefaultImpl;
using Microsoft.SqlTools.ServiceLayer.UnitTests.Utility;
using Moq;
using Xunit;
namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Formatter
{
public class ResourceProviderServiceTests
{
private const int SqlAzureFirewallBlockedErrorNumber = 40615;
private const int SqlAzureLoginFailedErrorNumber = 18456;
private string errorMessageWithIp = "error Message with 1.2.3.4 as IP address";
public ResourceProviderServiceTests()
{
HostMock = new Mock<IProtocolEndpoint>();
@@ -34,7 +47,194 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Formatter
protected ResourceProviderService ResourceProviderService { get; private set; }
[Fact]
public async Task TestHandleFirewallRuleIgnoresNonMssqlProvider()
{
// Given a non-MSSQL provider
var handleFirewallParams = new HandleFirewallRuleParams()
{
ErrorCode = SqlAzureFirewallBlockedErrorNumber,
ErrorMessage = errorMessageWithIp,
ConnectionTypeId = "Other"
};
// When I ask whether the service can process an error as a firewall rule request
await TestUtils.RunAndVerify<HandleFirewallRuleResponse>((context) => ResourceProviderService.ProcessHandleFirewallRuleRequest(handleFirewallParams, context), (response) =>
{
// Then I expect the response to be false and no IP information to be sent
Assert.NotNull(response);
Assert.False(response.Result);
Assert.Null(response.IpAddress);
Assert.Equal(Microsoft.SqlTools.ResourceProvider.Core.SR.FirewallRuleUnsupportedConnectionType, response.ErrorMessage);
});
}
[Fact]
public async Task TestHandleFirewallRuleSupportsMssqlProvider()
{
// Given a firewall error for the MSSQL provider
var handleFirewallParams = new HandleFirewallRuleParams()
{
ErrorCode = SqlAzureFirewallBlockedErrorNumber,
ErrorMessage = errorMessageWithIp,
ConnectionTypeId = "MSSQL"
};
// When I ask whether the service can process an error as a firewall rule request
await TestUtils.RunAndVerify<HandleFirewallRuleResponse>((context) => ResourceProviderService.ProcessHandleFirewallRuleRequest(handleFirewallParams, context), (response) =>
{
// Then I expect the response to be true and the IP address to be extracted
Assert.NotNull(response);
Assert.True(response.Result);
Assert.Equal("1.2.3.4", response.IpAddress);
Assert.Null(response.ErrorMessage);
});
}
[Fact]
public async Task TestHandleFirewallRuleIgnoresNonFirewallErrors()
{
// Given a login error for the MSSQL provider
var handleFirewallParams = new HandleFirewallRuleParams()
{
ErrorCode = SqlAzureLoginFailedErrorNumber,
ErrorMessage = errorMessageWithIp,
ConnectionTypeId = "MSSQL"
};
// When I ask whether the service can process an error as a firewall rule request
await TestUtils.RunAndVerify<HandleFirewallRuleResponse>((context) => ResourceProviderService.ProcessHandleFirewallRuleRequest(handleFirewallParams, context), (response) =>
{
// Then I expect the response to be false and no IP address to be defined
Assert.NotNull(response);
Assert.False(response.Result);
Assert.Equal(string.Empty, response.IpAddress);
Assert.Null(response.ErrorMessage);
});
}
[Fact]
public async Task TestHandleFirewallRuleDoesntBreakWithoutIp()
{
// Given a firewall error with no IP address in the error message
var handleFirewallParams = new HandleFirewallRuleParams()
{
ErrorCode = SqlAzureFirewallBlockedErrorNumber,
ErrorMessage = "No IP here",
ConnectionTypeId = "MSSQL"
};
// When I ask whether the service can process an error as a firewall rule request
await TestUtils.RunAndVerify<HandleFirewallRuleResponse>((context) => ResourceProviderService.ProcessHandleFirewallRuleRequest(handleFirewallParams, context), (response) =>
{
// Then I expect the response to be fakse as we require the known IP address to function
Assert.NotNull(response);
Assert.False(response.Result);
Assert.Equal(string.Empty, response.IpAddress);
Assert.Null(response.ErrorMessage);
});
}
[Fact]
public async Task TestCreateFirewallRuleBasicRequest()
{
// Given a firewall request for a valid subscription
string serverName = "myserver.database.windows.net";
var sub1Mock = new Mock<IAzureUserAccountSubscriptionContext>();
var sub2Mock = new Mock<IAzureUserAccountSubscriptionContext>();
var server = new SqlAzureResource(new Azure.Management.Sql.Models.Server("Somewhere",
"1234", "myserver", "SQLServer",
null, null, null, null, null, null, null,
fullyQualifiedDomainName: serverName));
var subsToServers = new List<Tuple<IAzureUserAccountSubscriptionContext, IEnumerable<IAzureSqlServerResource>>>()
{
Tuple.Create(sub1Mock.Object, Enumerable.Empty<IAzureSqlServerResource>()),
Tuple.Create(sub2Mock.Object, new IAzureSqlServerResource[] { server }.AsEnumerable())
};
var azureRmResponse = new FirewallRuleResponse()
{
Created = true,
StartIpAddress = null,
EndIpAddress = null
};
SetupDependencies(subsToServers, azureRmResponse);
// When I request the firewall be created
var createFirewallParams = new CreateFirewallRuleParams()
{
ServerName = serverName,
StartIpAddress = "1.1.1.1",
EndIpAddress = "1.1.1.255",
Account = CreateAccount(),
SecurityTokenMappings = new Dictionary<string, AccountSecurityToken>()
};
await TestUtils.RunAndVerify<CreateFirewallRuleResponse>(
(context) => ResourceProviderService.HandleCreateFirewallRuleRequest(createFirewallParams, context),
(response) =>
{
// Then I expect the response to be fakse as we require the known IP address to function
Assert.NotNull(response);
Assert.Null(response.ErrorMessage);
Assert.True(response.Result);
});
}
private void SetupDependencies(
IList<Tuple<IAzureUserAccountSubscriptionContext, IEnumerable<IAzureSqlServerResource>>> subsToServers,
FirewallRuleResponse response)
{
SetupCreateSession();
SetupReturnsSubscriptions(subsToServers.Select(s => s.Item1));
foreach(var s in subsToServers)
{
SetupAzureServers(s.Item1, s.Item2);
}
SetupFirewallResponse(response);
}
private void SetupReturnsSubscriptions(IEnumerable<IAzureUserAccountSubscriptionContext> subs)
{
AuthenticationManagerMock.Setup(a => a.GetSubscriptionsAsync()).Returns(() => Task.FromResult(subs));
}
private void SetupCreateSession()
{
ResourceManagerMock.Setup(r => r.CreateSessionAsync(It.IsAny<IAzureUserAccountSubscriptionContext>()))
.Returns((IAzureUserAccountSubscriptionContext sub) =>
{
var sessionMock = new Mock<IAzureResourceManagementSession>();
sessionMock.SetupProperty(s => s.SubscriptionContext, sub);
return Task.FromResult(sessionMock.Object);
});
}
private void SetupAzureServers(IAzureSubscriptionContext sub, IEnumerable<IAzureSqlServerResource> servers)
{
Func<IAzureResourceManagementSession, bool> isExpectedSub = (session) =>
{
return session.SubscriptionContext == sub;
};
ResourceManagerMock.Setup(r => r.GetSqlServerAzureResourcesAsync(
It.Is<IAzureResourceManagementSession>((session) => isExpectedSub(session))
)).Returns(() => Task.FromResult(servers));
}
private void SetupFirewallResponse(FirewallRuleResponse response)
{
ResourceManagerMock.Setup(r => r.CreateFirewallRuleAsync(
It.IsAny<IAzureResourceManagementSession>(),
It.IsAny<IAzureSqlServerResource>(),
It.IsAny<FirewallRuleRequest>())
).Returns(() => Task.FromResult(response));
}
private Account CreateAccount(bool needsReauthentication = false)
{
return new Account()
{
Key = new AccountKey()
{
AccountId = "MyAccount",
ProviderId = "MSSQL"
},
IsStale = needsReauthentication
};
}
}
}