Add Reactive implementation and unit tests

Octokit.Tests.Integration/Reactive/ObservableUserAdministrationClientTests.cs

@@ -0,0 +1,201 @@
+using System;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Octokit.Reactive;
+using Octokit.Tests.Integration.Helpers;
+using Xunit;
+
+namespace Octokit.Tests.Integration.Clients
+{
+    public class ObservableUserAdministrationClientTests
+    {
+        readonly IObservableGitHubClient _github;
+
+        public ObservableUserAdministrationClientTests()
+        {
+            _github = new ObservableGitHubClient(EnterpriseHelper.GetAuthenticatedClient());
+        }
+
+        private NewUser GenerateNewUserDetails()
+        {
+            string username = Helper.MakeNameWithTimestamp("user");
+            string email = string.Concat(username, "@company.com");
+            return new NewUser(username, email);
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanCreateAndDelete()
+        {
+            User checkUser = null;
+
+            // Create a new user
+            var newUser = GenerateNewUserDetails();
+
+            var observable = _github.User.Administration.Create(newUser);
+            var user = await observable;
+
+            // Check returned object (cant check email as it isn't public)
+            Assert.NotNull(user);
+            Assert.Equal(user.Login, newUser.Login);
+
+            // Get user to check they exist
+            checkUser = await _github.User.Get(newUser.Login);
+            Assert.Equal(checkUser.Login, newUser.Login);
+
+            // Delete the user
+            await _github.User.Administration.Delete(newUser.Login);
+
+            // Ensure user doesnt exist
+            try
+            {
+                checkUser = await _github.User.Get(newUser.Login);
+                if (checkUser != null)
+                {
+                    throw new Exception("User still exists!");
+                }
+            }
+            catch (ApiException e)
+            {
+                if (e.StatusCode != System.Net.HttpStatusCode.NotFound)
+                {
+                    throw;
+                }
+            }
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanRename()
+        {
+            string renamedUsername = Helper.MakeNameWithTimestamp("user-renamed");
+            // Create a disposable user for the test
+            using (var context = _github.CreateEnterpriseUserContext(GenerateNewUserDetails()).Result)
+            {
+                var observable = _github.User.Administration.Rename(
+                    context.UserLogin,
+                    new UserRename(renamedUsername));
+                var response = await observable;
+
+                Assert.NotNull(response);
+                Assert.StartsWith("Job queued to rename user", response.Message);
+                Assert.EndsWith(context.UserId.ToString(), response.Url);
+            }
+
+            // Remove user if it was already renamed
+            EnterpriseHelper.DeleteUser(renamedUsername);
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanAddAndDeleteImpersonationToken()
+        {
+            // Create a disposable user for the test
+            using (var context = _github.CreateEnterpriseUserContext(GenerateNewUserDetails()).Result)
+            {
+                // Create Impersonation token
+                var observable = _github.User.Administration.CreateImpersonationToken(
+                    context.UserLogin,
+                    new NewImpersonationToken(new string[] { "public_repo" }));
+                var token = await observable;
+
+                Assert.NotNull(token);
+                Assert.True(
+                    token.Scopes.Count() == 1 &&
+                    token.Scopes.All(s => s == "public_repo"));
+
+                // Delete Impersonation token
+                await _github.User.Administration.DeleteImpersonationToken(context.UserLogin);
+            }
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanPromoteAndDemote()
+        {
+            User checkUser = null;
+
+            // Create a disposable user for the test
+            using (var context = _github.CreateEnterpriseUserContext(GenerateNewUserDetails()).Result)
+            {
+                // Ensure user is not site admin
+                checkUser = await _github.User.Get(context.UserLogin);
+                Assert.False(checkUser.SiteAdmin);
+
+                // Promote to site admin
+                await _github.User.Administration.Promote(context.UserLogin);
+
+                // Ensure user is site admin
+                checkUser = await _github.User.Get(context.UserLogin);
+                Assert.True(checkUser.SiteAdmin);
+
+                // Demote user
+                await _github.User.Administration.Demote(context.UserLogin);
+
+                // Ensure user is not site admin
+                checkUser = await _github.User.Get(context.UserLogin);
+                Assert.False(checkUser.SiteAdmin);
+            }
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanSuspendAndUnsuspend()
+        {
+            User checkUser = null;
+
+            // Create a disposable user for the test
+            using (var context = _github.CreateEnterpriseUserContext(GenerateNewUserDetails()).Result)
+            {
+                // Ensure user is not suspended
+                checkUser = await _github.User.Get(context.UserLogin);
+                Assert.False(checkUser.Suspended);
+
+                // Suspend user
+                await _github.User.Administration.Suspend(context.UserLogin);
+
+                // Ensure user is suspended
+                checkUser = await _github.User.Get(context.UserLogin);
+                Assert.True(checkUser.Suspended);
+
+                // Unsuspend user
+                await _github.User.Administration.Unsuspend(context.UserLogin);
+
+                // Ensure user is not suspended
+                checkUser = await _github.User.Get(context.UserLogin);
+                Assert.False(checkUser.Suspended);
+            }
+        }
+
+        [GitHubEnterpriseTest(Skip = "Currently no way to add keys, so cant test listing keys")]
+        public async Task CanListAllPublicKeys()
+        {
+            // Create a disposable user for the test
+            using (var context = _github.CreateEnterpriseUserContext(GenerateNewUserDetails()).Result)
+            {
+                // Ensure user has a key
+                //var key = await _github.User.Keys.Create(new NewPublicKey("title", "key"));
+
+                // Get public keys
+                var observable = _github.User.Administration.ListAllPublicKeys();
+                var keys = await (observable.ToList());
+
+                Assert.NotNull(keys);
+                Assert.True(keys.Count > 0);
+
+                // Delete key
+                //await _github.User.Administration.DeletePublicKey(key.Id);
+            }
+        }
+
+        [GitHubEnterpriseTest(Skip = "Currently no way to add keys, so cant test deleting keys")]
+        public async Task CanDeletePublicKey()
+        {
+            // Create a disposable user for the test
+            using (var context = _github.CreateEnterpriseUserContext(GenerateNewUserDetails()).Result)
+            {
+                // Ensure user has a key
+                //var key = await _github.User.Keys.Create(new NewPublicKey("title", "key"));
+
+                // Delete key
+                //await _github.User.Administration.DeletePublicKey(key.Id);
+            }
+        }
+    }
+}