public void Should_Authenticate_Test_Admin_Identity()
{
IIdentityProvider serviceProvider = new IdentityProvider(_testAdminIdentity);
var userAccess = serviceProvider.Authenticate();
Assert.IsNotNull(userAccess);
}
public void Should_Not_Hit_Cache_When_Authenticating_The_First_Time()
{
var cacheMock = new Mock<ICache<UserAccess>>();
var restServiceMock = new Mock<IRestService>();
restServiceMock.Setup(m => m.Execute<AuthenticationResponse>(It.IsAny<string>(), It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<RequestSettings>())).Returns(new Response<AuthenticationResponse>(200, "OK", new AuthenticationResponse(), new List<HttpHeader>(), null));
restServiceMock.Setup(m => m.Execute<AuthenticationResponse>(It.IsAny<Uri>(), It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<RequestSettings>())).Returns(new Response<AuthenticationResponse>(200, "OK", new AuthenticationResponse(), new List<HttpHeader>(), null));
var identityProvider = new IdentityProvider(restServiceMock.Object, cacheMock.Object);
identityProvider.Authenticate(new RackspaceCloudIdentity());
cacheMock.Verify(m => m.Get(It.IsAny<string>(), It.IsAny<Func<UserAccess>>(), It.IsAny<bool>()), Times.Never());
}
public void Should_Always_Request_Fresh_Data_From_Cache_When_Authenticating()
{
var cacheMock = new Mock<ICache<UserAccess>>();
var restServiceMock = new Mock<IRestService>();
restServiceMock.Setup(m => m.Execute<AuthenticationResponse>(It.IsAny<string>(), It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<RequestSettings>())).Returns(new Response<AuthenticationResponse>(200, "OK", new AuthenticationResponse(), new List<HttpHeader>(), null));
restServiceMock.Setup(m => m.Execute<AuthenticationResponse>(It.IsAny<Uri>(), It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<RequestSettings>())).Returns(new Response<AuthenticationResponse>(200, "OK", new AuthenticationResponse(), new List<HttpHeader>(), null));
var identityProvider = new IdentityProvider(restServiceMock.Object, cacheMock.Object);
for (int i = 0; i < 100; i++)
{
identityProvider.Authenticate(new RackspaceCloudIdentity());
}
cacheMock.Verify(m => m.Get(It.IsAny<string>(), It.IsAny<Func<UserAccess>>(), true), Times.Exactly(100));
}
public void Should_Throw_Error_When_Authenticating_With_Invalid_Password()
{
var identity = new RackspaceCloudIdentity()
{
Username = _testIdentity.Username,
Password = "******"
};
IIdentityProvider serviceProvider = new IdentityProvider(identity);
try
{
var userAccess = serviceProvider.Authenticate();
throw new Exception("This code path is invalid, exception was expected.");
}
catch (net.openstack.Core.Exceptions.Response.ResponseException)
{
Assert.IsTrue(true);
}
}
public void Should_Return_List_Of_Users_Credentials_When_Requesting_As_Non_Admin()
{
IIdentityProvider provider = new IdentityProvider(_testIdentity);
var creds = provider.ListUserCredentials(_userDetails.Id);
Assert.IsNotNull(creds);
Assert.IsTrue(creds.Any());
foreach (var cred in creds)
{
Assert.IsFalse(string.IsNullOrWhiteSpace(cred.Name));
Assert.IsFalse(string.IsNullOrWhiteSpace(cred.APIKey));
Assert.IsFalse(string.IsNullOrWhiteSpace(cred.Username));
}
}
public void Should_Return_User_API_Credential_When_Requesting_As_Non_Admin()
{
IIdentityProvider provider = new IdentityProvider(_testIdentity);
var cred = provider.GetUserCredential(_userDetails.Id, "RAX-KSKEY:apiKeyCredentials");
Assert.IsNotNull(cred);
Assert.AreEqual("RAX-KSKEY:apiKeyCredentials", cred.Name);
Assert.IsFalse(string.IsNullOrWhiteSpace(cred.APIKey));
Assert.IsFalse(string.IsNullOrWhiteSpace(cred.Username));
}
public void Should_List_Only_Self_When_Retrieving_List_Of_Users_With_Non_Admin_Account()
{
IIdentityProvider serviceProvider = new IdentityProvider(new RackspaceCloudIdentity { Username = _testUser.Username, Password = _newTestUserPassword });
var users = serviceProvider.ListUsers();
Assert.IsTrue(users.Count() == 1);
Assert.AreEqual(_testUser.Username, users[0].Username);
}
public void Should_Return_The_Users_Tenant_When_Requesting_As_Non_Admin()
{
IIdentityProvider provider = new IdentityProvider(_testIdentity);
var tenants = provider.ListTenants();
Assert.IsTrue(tenants.Any());
if(!string.IsNullOrWhiteSpace(_testIdentity.TenantId))
{
Assert.IsTrue(tenants.Any(t => t.Id == _testIdentity.TenantId));
}
}
public void Should_Get_NewUser_When_Requesting_As_Self()
{
IIdentityProvider provider = new IdentityProvider(new RackspaceCloudIdentity { Username = _testUser.Username, Password = _newTestUserPassword });
var user = provider.GetUser(_testUser.Id);
Assert.IsNotNull(user);
}
public void Should_Update_NewUser_Username_And_Email_When_Requesting_As_Self()
{
IIdentityProvider provider = new IdentityProvider(new RackspaceCloudIdentity { Username = _testUser.Username, Password = _newTestUserPassword });
var user = new User
{
Id = _testUser.Id,
Username = "******",
Email = "*****@*****.**",
Enabled = true,
};
var updatedUser = provider.UpdateUser(user);
Assert.IsNotNull(updatedUser);
Assert.AreEqual("openstacknettestuser42", updatedUser.Username);
Assert.AreEqual("*****@*****.**", updatedUser.Email);
Assert.AreEqual(true, updatedUser.Enabled);
}
public void Should_Update_NewUser_Username_And_Email_When_Requesting_As_User_Admin()
{
IIdentityProvider provider = new IdentityProvider();
var user = new User
{
Id = _newTestUser1.Id,
Username = "******",
Email = "*****@*****.**",
Enabled = true
};
var updatedUser = provider.UpdateUser(_testIdentity, user);
Assert.IsNotNull(updatedUser);
Assert.AreEqual("openstacknettestuser12", updatedUser.Username);
Assert.AreEqual("*****@*****.**", updatedUser.Email);
Assert.AreEqual(true, updatedUser.Enabled);
Assert.IsTrue(string.IsNullOrWhiteSpace(updatedUser.DefaultRegion));
}
public void Should_List_Details_Of_Other_User_When_Retrieving_User_By_Id_With_Admin_Account()
{
IIdentityProvider serviceProvider = new IdentityProvider(_testAdminIdentity);
var details = serviceProvider.GetUser(_userDetails.Id);
Assert.IsNotNull(details);
Assert.AreEqual(_testIdentity.Username, details.Username);
}
public void Should_Throw_Exception_When_Requesting_The_NewUser_After_It_Has_Been_Deleted_When_Requesting_As_User_Admin()
{
IIdentityProvider provider = new IdentityProvider(_testIdentity);
try
{
provider.GetUser(_testUser.Id);
throw new Exception("This code path is invalid, exception was expected.");
}
catch(Exception ex)
{
Assert.IsTrue(true);
}
}
public void Should_List_Multiple_Users_When_Retrieving_List_Of_Users_With_Admin_Account()
{
IIdentityProvider serviceProvider = new IdentityProvider(_testAdminIdentity);
var users = serviceProvider.ListUsers();
Assert.IsTrue(users.Any());
}
public void Should_Delete_NewUser_When_Requesting_As_User_Admin()
{
IIdentityProvider provider = new IdentityProvider(_testIdentity);
var response = provider.DeleteUser(_testUser.Id);
Assert.IsTrue(response);
}
public void Should_Authenticate_NewUser()
{
Assert.IsNotNull(_testUser);
IIdentityProvider provider = new IdentityProvider();
var userAccess =
provider.Authenticate(new RackspaceCloudIdentity
{Username = _testUser.Username, Password = _newTestUserPassword});
Assert.IsNotNull(userAccess);
}
public void Should_Throw_Exception_When_Trying_To_Get_Details_Of_A_Different_User_When_Retrieving_User_By_Id_With_Non_Admin_Account()
{
IIdentityProvider serviceProvider = new IdentityProvider(_testIdentity);
try
{
var details = serviceProvider.GetUser(_adminUserDetails.Id);
throw new Exception("This code path is invalid, exception was expected.");
}
catch (net.openstack.Core.Exceptions.Response.ResponseException)
{
Assert.IsTrue(true);
}
}
public void Should_List_Only_User_In_Account_When_Retrieving_List_Of_Users_With_User_Admin_Account()
{
IIdentityProvider serviceProvider = new IdentityProvider(_testIdentity);
var users = serviceProvider.ListUsers();
Assert.IsTrue(users.Any());
Assert.AreEqual(_testIdentity.Username, users[0].Username);
}
public void Should_Update_NewUser_Username_And_Email_And_Default_Region_When_Requesting_As_User_Admin()
{
IIdentityProvider provider = new IdentityProvider(_testIdentity);
var user = new User
{
Id = _testUser.Id,
Username = "******",
Email = "*****@*****.**",
Enabled = true,
DefaultRegion = "DFW"
};
var updatedUser = provider.UpdateUser(user);
Assert.IsNotNull(updatedUser);
Assert.AreEqual("openstacknettestuser32", updatedUser.Username);
Assert.AreEqual("*****@*****.**", updatedUser.Email);
Assert.AreEqual(true, updatedUser.Enabled);
Assert.AreEqual("DFW", updatedUser.DefaultRegion);
}
public void Should_Add_New_User_2_With_Specifying_A_Password_But_Not_Default_Region_To_Account_When_Requesting_As_User_Admin()
{
IIdentityProvider provider = new IdentityProvider(_testIdentity);
var newUser = provider.AddUser(new NewUser { Username = "******", Email = "*****@*****.**", Enabled = true, Password = NewUserPassword });
_newTestUserPassword = newUser.Password;
Assert.IsNotNull(newUser);
Assert.AreEqual("openstacknettestuser2", newUser.Username);
Assert.AreEqual("*****@*****.**", newUser.Email);
Assert.AreEqual(true, newUser.Enabled);
Assert.AreEqual(NewUserPassword, newUser.Password);
Assert.IsFalse(string.IsNullOrWhiteSpace(newUser.Password));
}
public void Should_List_Details_Of_Self_When_Retrieving_User_By_Name_With_Admin_Account()
{
IIdentityProvider serviceProvider = new IdentityProvider(_testAdminIdentity);
_adminUserDetails = serviceProvider.GetUserByName(_testAdminIdentity.Username);
Assert.IsNotNull(_adminUserDetails);
Assert.AreEqual(_testAdminIdentity.Username, _adminUserDetails.Username);
}
public void Should_Retrieve_New_User_2_As_User_Admin()
{
IIdentityProvider provider = new IdentityProvider(_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_Add_New_User_Without_Specifying_A_Password_Or_Default_Region_To_Account_When_Requesting_As_User_Admin()
{
IIdentityProvider provider = new IdentityProvider();
_newTestUser1 = provider.AddUser(_testIdentity, new NewUser { Username = "******", Email = "*****@*****.**", Enabled = true });
Assert.IsNotNull(_newTestUser1);
Assert.AreEqual("openstacknettestuser1", _newTestUser1.Username);
Assert.AreEqual("*****@*****.**", _newTestUser1.Email);
Assert.AreEqual(true, _newTestUser1.Enabled);
Assert.IsFalse(string.IsNullOrWhiteSpace(_newTestUser1.Password));
}
