Return LoginResult from LoginManager.

So we can return the scopes as well as the user.

Author: grokys

src/GitHub.Api/ILoginManager.cs

@@ -21,11 +21,11 @@ public interface ILoginManager
         /// <param name="client">An octokit client configured to access the server.</param>
         /// <param name="userName">The username.</param>
         /// <param name="password">The password.</param>
-        /// <returns>The logged in user.</returns>
+        /// <returns>A <see cref="LoginResult"/> with the details of the successful login.</returns>
         /// <exception cref="AuthorizationException">
         /// The login authorization failed.
         /// </exception>
-        Task<User> Login(HostAddress hostAddress, IGitHubClient client, string userName, string password);
+        Task<LoginResult> Login(HostAddress hostAddress, IGitHubClient client, string userName, string password);
 
         /// <summary>
         /// Attempts to log into a GitHub server via OAuth in the browser.
@@ -35,11 +35,11 @@ public interface ILoginManager
         /// <param name="oauthClient">An octokit OAuth client configured to access the server.</param>
         /// <param name="openBrowser">A callback that should open a browser at the requested URL.</param>
         /// <param name="cancel">A cancellation token used to cancel the operation.</param>
-        /// <returns>The logged in user.</returns>
+        /// <returns>A <see cref="LoginResult"/> with the details of the successful login.</returns>
         /// <exception cref="AuthorizationException">
         /// The login authorization failed.
         /// </exception>
-        Task<User> LoginViaOAuth(
+        Task<LoginResult> LoginViaOAuth(
             HostAddress hostAddress,
             IGitHubClient client,
             IOauthClient oauthClient,
@@ -52,7 +52,8 @@ Task<User> LoginViaOAuth(
         /// <param name="hostAddress">The address of the server.</param>
         /// <param name="client">An octokit client configured to access the server.</param>
         /// <param name="token">The token.</param>
-        Task<User> LoginWithToken(
+        /// <returns>A <see cref="LoginResult"/> with the details of the successful login.</returns>
+        Task<LoginResult> LoginWithToken(
             HostAddress hostAddress,
             IGitHubClient client,
             string token);
@@ -62,11 +63,11 @@ Task<User> LoginWithToken(
         /// </summary>
         /// <param name="hostAddress">The address of the server.</param>
         /// <param name="client">An octokit client configured to access the server.</param>
-        /// <returns>The logged in user.</returns>
+        /// <returns>A <see cref="LoginResult"/> with the details of the successful login.</returns>
         /// <exception cref="AuthorizationException">
         /// The login authorization failed.
         /// </exception>
-        Task<User> LoginFromCache(HostAddress hostAddress, IGitHubClient client);
+        Task<LoginResult> LoginFromCache(HostAddress hostAddress, IGitHubClient client);
 
         /// <summary>
         /// Logs out of GitHub server.

src/GitHub.Api/LoginManager.cs

@@ -70,7 +70,7 @@ public LoginManager(
         }
 
         /// <inheritdoc/>
-        public async Task<User> Login(
+        public async Task<LoginResult> Login(
             HostAddress hostAddress,
             IGitHubClient client,
             string userName,
@@ -129,7 +129,7 @@ public async Task<User> Login(
         }
 
         /// <inheritdoc/>
-        public async Task<User> LoginViaOAuth(
+        public async Task<LoginResult> LoginViaOAuth(
             HostAddress hostAddress,
             IGitHubClient client,
             IOauthClient oauthClient,
@@ -152,13 +152,13 @@ public async Task<User> LoginViaOAuth(
             var token = await oauthClient.CreateAccessToken(request).ConfigureAwait(false);
 
             await keychain.Save("[oauth]", token.AccessToken, hostAddress).ConfigureAwait(false);
-            var user = await ReadUserWithRetry(client).ConfigureAwait(false);
-            await keychain.Save(user.Login, token.AccessToken, hostAddress).ConfigureAwait(false);
-            return user;
+            var result = await ReadUserWithRetry(client).ConfigureAwait(false);
+            await keychain.Save(result.User.Login, token.AccessToken, hostAddress).ConfigureAwait(false);
+            return result;
         }
 
         /// <inheritdoc/>
-        public async Task<User> LoginWithToken(
+        public async Task<LoginResult> LoginWithToken(
             HostAddress hostAddress,
             IGitHubClient client,
             string token)
@@ -171,9 +171,9 @@ public async Task<User> LoginWithToken(
 
             try
             {
-                var user = await ReadUserWithRetry(client).ConfigureAwait(false);
-                await keychain.Save(user.Login, token, hostAddress).ConfigureAwait(false);
-                return user;
+                var result = await ReadUserWithRetry(client).ConfigureAwait(false);
+                await keychain.Save(result.User.Login, token, hostAddress).ConfigureAwait(false);
+                return result;
             }
             catch
             {
@@ -183,7 +183,7 @@ public async Task<User> LoginWithToken(
         }
 
         /// <inheritdoc/>
-        public Task<User> LoginFromCache(HostAddress hostAddress, IGitHubClient client)
+        public Task<LoginResult> LoginFromCache(HostAddress hostAddress, IGitHubClient client)
         {
             Guard.ArgumentNotNull(hostAddress, nameof(hostAddress));
             Guard.ArgumentNotNull(client, nameof(client));
@@ -349,7 +349,7 @@ e is ForbiddenException ||
                  apiException?.StatusCode == (HttpStatusCode)422);
         }
 
-        async Task<User> ReadUserWithRetry(IGitHubClient client)
+        async Task<LoginResult> ReadUserWithRetry(IGitHubClient client)
         {
             var retry = 0;
 
@@ -370,7 +370,7 @@ async Task<User> ReadUserWithRetry(IGitHubClient client)
             }
         }
 
-        async Task<User> GetUserAndCheckScopes(IGitHubClient client)
+        async Task<LoginResult> GetUserAndCheckScopes(IGitHubClient client)
         {
             var response = await client.Connection.Get<User>(
                 UserEndpoint, null, null).ConfigureAwait(false);
@@ -384,7 +384,7 @@ async Task<User> GetUserAndCheckScopes(IGitHubClient client)
 
                 if (ScopesMatch(minimumScopes, returnedScopes))
                 {
-                    return response.Body;
+                    return new LoginResult(response.Body, returnedScopes);
                 }
                 else
                 {

src/GitHub.Api/LoginResult.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using Octokit;
+
+namespace GitHub.Api
+{
+    /// <summary>
+    /// Holds the result of a successful login by <see cref="ILoginManager"/>.
+    /// </summary>
+    public class LoginResult
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LoginResult"/> class.
+        /// </summary>
+        /// <param name="user">The logged-in user.</param>
+        /// <param name="scopes">The login scopes.</param>
+        public LoginResult(User user, IReadOnlyList<string> scopes)
+        {
+            User = user;
+            Scopes = scopes;
+        }
+
+        /// <summary>
+        /// Gets the login scopes.
+        /// </summary>
+        public IReadOnlyList<string> Scopes { get; }
+
+        /// <summary>
+        /// Gets the logged-in user.
+        /// </summary>
+        public User User { get; }
+    }
+}

src/GitHub.VisualStudio/Services/ConnectionManager.cs

@@ -79,8 +79,8 @@ public async Task<IConnection> LogIn(HostAddress address, string userName, strin
             }
 
             var client = CreateClient(address);
-            var user = await loginManager.Login(address, client, userName, password);
-            var connection = new Connection(address, userName, user);
+            var login = await loginManager.Login(address, client, userName, password);
+            var connection = new Connection(address, userName, login.User);
 
             conns.Add(connection);
             await SaveConnections();
@@ -100,8 +100,8 @@ public async Task<IConnection> LogInViaOAuth(HostAddress address, CancellationTo
 
             var client = CreateClient(address);
             var oauthClient = new OauthClient(client.Connection);
-            var user = await loginManager.LoginViaOAuth(address, client, oauthClient, OpenBrowser, cancel);
-            var connection = new Connection(address, user.Login, user);
+            var login = await loginManager.LoginViaOAuth(address, client, oauthClient, OpenBrowser, cancel);
+            var connection = new Connection(address, login.User.Login, login.User);
 
             conns.Add(connection);
             await SaveConnections();
@@ -121,8 +121,8 @@ public async Task<IConnection> LogInWithToken(HostAddress address, string token)
             }
 
             var client = CreateClient(address);
-            var user = await loginManager.LoginWithToken(address, client, token);
-            var connection = new Connection(address, user.Login, user);
+            var login = await loginManager.LoginWithToken(address, client, token);
+            var connection = new Connection(address, login.User.Login, login.User);
 
             conns.Add(connection);
             await SaveConnections();
@@ -156,8 +156,8 @@ public async Task Retry(IConnection connection)
             try
             {
                 var client = CreateClient(c.HostAddress);
-                var user = await loginManager.LoginFromCache(connection.HostAddress, client);
-                c.SetSuccess(user);
+                var login = await loginManager.LoginFromCache(connection.HostAddress, client);
+                c.SetSuccess(login.User);
                 await usageTracker.IncrementCounter(x => x.NumberOfLogins);
             }
             catch (Exception e)
@@ -201,12 +201,12 @@ async Task LoadConnections(ObservableCollection<IConnection> result)
                 foreach (Connection connection in result)
                 {
                     var client = CreateClient(connection.HostAddress);
-                    User user = null;
+                    LoginResult login = null;
 
                     try
                     {
-                        user = await loginManager.LoginFromCache(connection.HostAddress, client);
-                        connection.SetSuccess(user);
+                        login = await loginManager.LoginFromCache(connection.HostAddress, client);
+                        connection.SetSuccess(login.User);
                         await usageTracker.IncrementCounter(x => x.NumberOfLogins);
                     }
                     catch (Exception e)

test/GitHub.Api.UnitTests/LoginManagerTests.cs

@@ -48,7 +48,7 @@ public async Task LoggedInUserIsReturned()
             var target = new LoginManager(keychain, tfa, oauthListener, "id", "secret", scopes, scopes);
             var result = await target.Login(host, client, "foo", "bar");
 
-            Assert.That(user, Is.SameAs(result));
+            Assert.That(user, Is.SameAs(result.User));
         }
 
         [Test]

test/GitHub.VisualStudio.UnitTests/Services/ConnectionManagerTests.cs

@@ -261,12 +261,14 @@ static IConnectionCache CreateConnectionCache(params string[] hosts)
     static ILoginManager CreateLoginManager()
     {
         var result = Substitute.For<ILoginManager>();
+        result.Login(null, null, null, null)
+            .ReturnsForAnyArgs(new LoginResult(new User(), new[] { "scope1" }));
         result.Login(HostAddress.Create("invalid.com"), Arg.Any<IGitHubClient>(), Arg.Any<string>(), Arg.Any<string>())
-            .Returns<User>(_ => { throw new AuthorizationException(); });
+            .Returns<LoginResult>(_ => { throw new AuthorizationException(); });
         result.LoginFromCache(null, null)
-            .ReturnsForAnyArgs(new User());
+            .ReturnsForAnyArgs(new LoginResult(new User(), new[] { "scope1" }));
         result.LoginFromCache(HostAddress.Create("invalid.com"), Arg.Any<IGitHubClient>())
-            .Returns<User>(_ => { throw new AuthorizationException(); });
+            .Returns<LoginResult>(_ => { throw new AuthorizationException(); });
         return result;
     }
 }