public void DeleteRoleFromUser()
        {
            var identity = new CloudIdentity { Username = "******", APIKey = "{apiKey}" };
            var provider = new CloudIdentityProvider(identity);

            #region DeleteRoleFromUser
            User user = provider.GetUserByName("{username}", null);
            provider.DeleteRoleFromUser(user.Id, "{roleId}", null);
            #endregion
        }
        public void UpdateUser()
        {
            var identity = new CloudIdentity { Username = "******", APIKey = "{apiKey}" };
            var provider = new CloudIdentityProvider(identity);

            #region UpdateUser
            User user = provider.GetUserByName("{username}", null);
            user.Username = "******";
            provider.UpdateUser(user, null);
            #endregion
        }
        public void Should_Throw_Exception_When_Trying_To_Get_Details_Of_A_Different_User_When_Retrieving_User_By_Name_With_Non_Admin_Account()
        {
            IIdentityProvider serviceProvider = new CloudIdentityProvider(_testIdentity);

            try
            {
                var details = serviceProvider.GetUserByName(_testAdminIdentity.Username);

                throw new Exception("This code path is invalid, exception was expected.");
            }
            catch (net.openstack.Core.Exceptions.Response.ResponseException)
            {
                Assert.IsTrue(true);
            }
        }
        public void Should_Retrieve_New_User_2_As_User_Admin()
        {
            IIdentityProvider provider = new CloudIdentityProvider(_testAdminIdentity);

            _testUser = provider.GetUserByName("openstacknettestuser2");

            Assert.IsNotNull(_testUser);
            Assert.AreEqual("openstacknettestuser2", _testUser.Username);
            Assert.AreEqual("*****@*****.**", _testUser.Email);
            Assert.AreEqual(true, _testUser.Enabled);
        }
        public void Should_List_Details_Of_Other_User_When_Retrieving_User_By_Name_With_Admin_Account()
        {
            IIdentityProvider serviceProvider = new CloudIdentityProvider(_testAdminIdentity);

            var details = serviceProvider.GetUserByName(_testIdentity.Username);

            Assert.IsNotNull(details);
            Assert.AreEqual(_testIdentity.Username, details.Username);
        }
        public void Should_List_Details_Of_Self_When_Retrieving_User_By_Name_With_Non_Admin_Account()
        {
            ICloudIdentityProvider serviceProvider = new CloudIdentityProvider(_testIdentity);

            _userDetails = serviceProvider.GetUserByName(_testIdentity.Username);

            Assert.IsNotNull(_userDetails);
            Assert.AreEqual(_testIdentity.Username, _userDetails.Username);
        }
        public void TestGetUserCredential()
        {
            IIdentityProvider provider = new CloudIdentityProvider(Bootstrapper.Settings.TestIdentity);
            User user = provider.GetUserByName(Bootstrapper.Settings.TestIdentity.Username);
            IEnumerable<UserCredential> credentials = provider.ListUserCredentials(user.Id);
            Assert.IsNotNull(credentials);
            Assert.IsTrue(credentials.Any());

            foreach (UserCredential credential in credentials)
            {
                UserCredential value = provider.GetUserCredential(user.Id, credential.Name);
                Assert.AreEqual(credential.Username, value.Username);
                Assert.AreEqual(credential.Name, value.Name);
                Assert.AreEqual(credential.APIKey, value.APIKey);
            }

            Console.WriteLine(JsonConvert.SerializeObject(credentials, Formatting.Indented));
        }
        public void TestListUserCredentials()
        {
            IIdentityProvider provider = new CloudIdentityProvider(Bootstrapper.Settings.TestIdentity);
            User user = provider.GetUserByName(Bootstrapper.Settings.TestIdentity.Username);
            IEnumerable<UserCredential> credentials = provider.ListUserCredentials(user.Id);
            Assert.IsNotNull(credentials);
            Assert.IsTrue(credentials.Any());

            foreach (IGrouping<string, UserCredential> grouping in credentials.GroupBy(i => i.Name))
            {
                Console.WriteLine(grouping.Key);
                foreach (UserCredential credential in grouping)
                    Console.WriteLine("    {0}: {1}", credential.Username, credential.APIKey);
            }
        }
        public void TestGetUser()
        {
            IIdentityProvider provider = new CloudIdentityProvider(Bootstrapper.Settings.TestIdentity);
            User userByName = provider.GetUserByName(Bootstrapper.Settings.TestIdentity.Username);
            Assert.IsNotNull(userByName);
            Assert.AreEqual(Bootstrapper.Settings.TestIdentity.Username, userByName.Username);
            Assert.IsNotNull(userByName.Id);

            User user = provider.GetUser(userByName.Id);
            Assert.IsNotNull(user);
            Assert.AreEqual(Bootstrapper.Settings.TestIdentity.Username, user.Username);
            Assert.AreEqual(userByName.Id, user.Id);

            Console.WriteLine("User \"{0}\" (id: {1})", user.Username, user.Id);
            if (!user.Enabled)
                Console.WriteLine("    Disabled");
            if (!string.IsNullOrEmpty(user.Email))
                Console.WriteLine("    Email: {0}", user.Email);
            if (!string.IsNullOrEmpty(user.DefaultRegion))
                Console.WriteLine("    Default region: {0}", user.DefaultRegion);
        }