Merge branch 'master' into api-paging-part-deux

2026-06-06 20:13:40 +00:00 · 2016-02-24 11:40:43 +11:00
parent 03a5542fe6 84539f7baf
commit aafdda2f00
54 changed files with 2609 additions and 69 deletions
@@ -0,0 +1,96 @@
+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
+{
+    public class ObservableEnterpriseLdapClientTests : IDisposable
+    {
+        readonly IObservableGitHubClient _github;
+
+        readonly string _testUser = "test-user";
+        readonly string _distinguishedNameUser = "uid=test-user,ou=users,dc=company,dc=com";
+        
+        readonly EnterpriseTeamContext _context;
+        readonly string _distinguishedNameTeam = "cn=test-team,ou=groups,dc=company,dc=com";
+        
+        public ObservableEnterpriseLdapClientTests()
+        {
+            _github = new ObservableGitHubClient(EnterpriseHelper.GetAuthenticatedClient());
+
+            NewTeam newTeam = new NewTeam(Helper.MakeNameWithTimestamp("test-team")) { Description = "Test Team" };
+            _context = _github.CreateEnterpriseTeamContext(EnterpriseHelper.Organization, newTeam).Result;
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanUpdateUserMapping()
+        {
+            var newLDAPMapping = new NewLdapMapping(_distinguishedNameUser);
+            var observable =
+                _github.Enterprise.Ldap.UpdateUserMapping(_testUser, newLDAPMapping);
+            var ldapUser = await observable;
+
+            Assert.NotNull(ldapUser);
+            Assert.NotNull(ldapUser.LdapDistinguishedName);
+            Assert.Equal(ldapUser.LdapDistinguishedName, _distinguishedNameUser);
+
+            // Get user and check mapping was updated
+            var checkUser = await _github.User.Get(_testUser);
+            Assert.Equal(checkUser.Login, ldapUser.Login);
+            Assert.Equal(checkUser.LdapDistinguishedName, _distinguishedNameUser);
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanQueueSyncUserMapping()
+        {
+            var observable =
+                _github.Enterprise.Ldap.QueueSyncUserMapping(_testUser);
+            var response = await observable;
+
+            // Check response message indicates LDAP sync was queued
+            Assert.NotNull(response);
+            Assert.NotNull(response.Status);
+            Assert.True(response.Status == "queued");
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanUpdateTeamMapping()
+        {
+            var newLDAPMapping = new NewLdapMapping(_distinguishedNameTeam);
+            var observable =
+                _github.Enterprise.Ldap.UpdateTeamMapping(_context.TeamId, newLDAPMapping);
+            var ldapTeam = await observable;
+
+            Assert.NotNull(ldapTeam);
+            Assert.NotNull(ldapTeam.LdapDistinguishedName);
+            Assert.Equal(ldapTeam.LdapDistinguishedName, _distinguishedNameTeam);
+
+            // Get Team and check mapping was updated
+            var checkTeam = await _github.Organization.Team.Get(_context.TeamId);
+            Assert.Equal(checkTeam.Name, ldapTeam.Name);
+            Assert.Equal(checkTeam.LdapDistinguishedName, _distinguishedNameTeam);
+        }
+
+        [GitHubEnterpriseTest]
+        public async Task CanQueueSyncTeamMapping()
+        {
+            var observable =
+                _github.Enterprise.Ldap.QueueSyncTeamMapping(_context.TeamId);
+            var response = await observable;
+
+            // Check response message indicates LDAP sync was queued
+            Assert.NotNull(response);
+            Assert.NotNull(response.Status);
+            Assert.True(response.Status == "queued");
+        }
+
+        public void Dispose()
+        {
+            _context.Dispose();
+        }
+    }
+}
@@ -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);
+            }
+        }
+    }
+}