public void If_role_parameter_empty_reset_user_roles()
{
#region Arrange
var roleProvider = _mocker.DynamicMock <IRoleProvider>();
var profile = new ProfileModelDto {
Role = "", LoginName = "user"
};
var service = new ProfileService(roleProvider);
#endregion
#region Act
using (_mocker.Record())
{
Expect.Call(roleProvider.GetRolesForUser("user")).Return(new[] { "unusedRole" });
Expect.Call(() => roleProvider.RemoveUserFromRole("user", "unusedRole"));
}
using (_mocker.Playback())
{
service.UpdateRole(profile, false);
}
#endregion
}
public void Can_get_test_details()
{
#region Arrange
var test = new TestDto
{
Author = ProfileModelDto.Map(TestPofile),
CreationDate = DateTime.Now,
Name = "new test",
TestType = TestTypeModelDto.Map(TestTestType),
Questions = new List <TestQuestionModelDto> {
TestQuestionModelDto.Map(TestQuestion)
}
};
using (var session = DataAccess.OpenSession())
{
var course = session.Get <CourseModel>(1);
course.Tests.Add(TestDto.UnMap(test));
session.Flush();
}
#endregion
#region Act
test = new TestService().GetTestDetails(3);
#endregion
#region Assert
Assert.That(test.Name, Is.EqualTo("new test"));
Assert.That(test.Questions.Count, Is.EqualTo(1));
Assert.That(test.Questions.First().Answers.Count, Is.EqualTo(1));
#endregion
}
public void Is_no_role_create_new_role()
{
#region Arrange
var roleProvider = _mocker.DynamicMock <IRoleProvider>();
var profile = new ProfileModelDto {
Role = "admin", LoginName = "user"
};
var service = new ProfileService(roleProvider);
#endregion
#region Act
using (_mocker.Record())
{
Expect.Call(roleProvider.RoleExists("admin")).Return(false);
Expect.Call(() => roleProvider.CreateRole("admin"));
Expect.Call(roleProvider.IsUserInRole("user", "admin")).Repeat.Never();
Expect.Call(roleProvider.GetRolesForUser("user")).Return(new[] { "unusedRole" });
Expect.Call(() => roleProvider.RemoveUserFromRole("user", "unusedRole")).Repeat.Once();
Expect.Call(() => roleProvider.AddUserToRole("user", "admin"));
}
using (_mocker.Playback())
{
service.UpdateRole(profile, true);
}
#endregion
}
public bool UpdateRole(ProfileModelDto profile,bool createIfNotExist)
{
var role = profile.Role;
var userName = profile.LoginName;
try
{
if (!String.IsNullOrWhiteSpace(role))
{
if (_roleProvider.RoleExists(role) && !_roleProvider.IsUserInRole(userName, role))
{
DeleteUserFromRoles(userName);
_roleProvider.AddUserToRole(userName, role);
}
else if (!_roleProvider.RoleExists(role) && createIfNotExist)
{
_roleProvider.CreateRole(role);
DeleteUserFromRoles(userName);
_roleProvider.AddUserToRole(userName, role);
}
}
else
{
DeleteUserFromRoles(userName);
}
return true;
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.UpdateRole - {0}", ex.Message);
return false;
}
}
public void If_no_role_dont_update()
{
#region Arrange
var roleProvider = _mocker.DynamicMock <IRoleProvider>();
var profile = new ProfileModelDto {
Role = "admin", LoginName = "user"
};
var service = new ProfileService(roleProvider);
#endregion
#region Act
using (_mocker.Record())
{
Expect.Call(roleProvider.RoleExists("admin")).Return(false);
Expect.Call(() => roleProvider.AddUserToRole("user", "admin")).Repeat.Never();
Expect.Call(() => roleProvider.RemoveUserFromRole("user", "unusedRole")).Repeat.Never().IgnoreArguments();
}
using (_mocker.Playback())
{
service.UpdateRole(profile, false);
}
#endregion
}
public void Can_delete_profile()
{
#region Arrange
var profile = new ProfileModel {
LoginName = "delete test", Email = "*****@*****.**", IsActive = true
};
int id = -1;
DataAccess.InTransaction(session =>
{
id = (int)session.Save(profile);
});
#endregion
#region Act
var profileDto = ProfileModelDto.Map(profile);
profileDto.ID = id;
bool deleteOk = new ProfileService().DeleteProfile(profileDto);
IList <ProfileModel> profiles = null;
DataAccess.InTransaction(session =>
{
profiles = session.CreateCriteria(typeof(ProfileModel)).List <ProfileModel>();
});
#endregion
#region Assert
Assert.That(deleteOk, Is.True);
Assert.That(profiles.Count, Is.EqualTo(1));
#endregion
}
public void Can_update_profile()
{
#region Arrange
ProfileModel profile = null;
DataAccess.InTransaction(session =>
{
profile = session.Get <ProfileModel>(1);
});
profile.LoginName = "update test";
#endregion
#region Act
bool updateOk = new ProfileService().UpdateProfile(ProfileModelDto.Map(profile));
#endregion
ProfileModel testProfile = null;
DataAccess.InTransaction(session =>
{
testProfile = session.Get <ProfileModel>(1);
});
#region Assert
Assert.That(updateOk, Is.True);
Assert.That(testProfile.LoginName, Is.EqualTo("update test"));
#endregion
}
public void SetUp()
{
Mock = new MockRepository();
ProfileService = Mock.DynamicMock<IProfileService>();
ProfileController = new ProfileController(ProfileService);
Profile = new ProfileModelDto { ID = 1, Email = "*****@*****.**", Role = "admin", LoginName = "testuser" };
ProfileList = new[]
{
new ProfileModelDto { ID=1},
new ProfileModelDto { ID=2}
};
}
public bool DeleteProfile(ProfileModelDto profile)
{
try
{
DataAccess.InTransaction(session => session.Delete(ProfileModelDto.UnMap(profile)));
return true;
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.DeleteProfile - {0}", ex.Message);
return false;
}
}
public List<ProfileModelDto> GetAllProfiles()
{
try
{
var profiles = new Repository<ProfileModel>().GetAll().ToList();
return ProfileModelDto.Map(profiles);
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.GetAllProfiles - {0}", ex.Message);
return null;
}
}
public void SetUp()
{
Mock = new MockRepository();
GroupService = Mock.DynamicMock<IGroupService>();
ProfileService = Mock.DynamicMock<IProfileService>();
GroupController = new GroupController(GroupService, JournalService);
SampleGroup = new GroupModelDto { ID = 1, GroupName = "test" };
SampleProfile = new ProfileModelDto { ID = 1, LoginName = "test" };
SampleGroupList = new List<GroupModelDto>
{
new GroupModelDto(),
new GroupModelDto()
};
}
public ProfileModelDto GetByName(string userName)
{
try
{
using (var session = DataAccess.OpenSession())
{
var profiles = (List<ProfileModel>)session.CreateQuery(new QueryProfilesByName(userName).Query).List<ProfileModel>();
return ProfileModelDto.Map(profiles.First());
}
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.GetByName - {0}", ex.Message);
return null;
}
}
public ProfileModelDto GetProfile(int id)
{
try
{
ProfileModel profile;
using (var session = DataAccess.OpenSession())
{
profile = session.Get<ProfileModel>(id);
}
return ProfileModelDto.Map(profile);
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.GetProfile- {0}", ex.Message);
return null;
}
}
public int AddProfile(ProfileModelDto profile)
{
try
{
int id = -1;
DataAccess.InTransaction(session =>
{
id = (int)session.Save(ProfileModelDto.UnMap(profile));
});
return id;
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.AddProfile - {0}", ex.Message);
return -1;
}
}
public int AddProfile(ProfileModelDto profile)
{
try
{
int id = -1;
DataAccess.InTransaction(session =>
{
id = (int)session.Save(ProfileModelDto.UnMap(profile));
});
return id;
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.AddProfile - {0}", ex.Message);
return -1;
}
}
public void SetUp()
{
Mock = new MockRepository();
ProfileService = Mock.DynamicMock <IProfileService>();
ProfileController = new ProfileController(ProfileService);
Profile = new ProfileModelDto {
ID = 1, Email = "*****@*****.**", Role = "admin", LoginName = "testuser"
};
ProfileList = new[]
{
new ProfileModelDto {
ID = 1
},
new ProfileModelDto {
ID = 2
}
};
}
public void Can_add_test()
{
#region Arrange
var test = new TestDto
{
Author = ProfileModelDto.Map(TestPofile), CreationDate = DateTime.Now, Name = "new test", TestType = TestTypeModelDto.Map(TestTestType)
};
#endregion
#region Act
new TestService().AddTestToCourse(1, test);
//var tests= new CourseService().GetAllTestsSignatures(1);
#endregion
#region Assert
//Assert.That(tests.Count,Is.EqualTo(1));
//Assert.That(tests.First().Name, Is.EqualTo("new test"));
#endregion
}
public void SetUp()
{
Mock = new MockRepository();
GroupService = Mock.DynamicMock <IGroupService>();
ProfileService = Mock.DynamicMock <IProfileService>();
GroupController = new GroupController(GroupService, JournalService);
SampleGroup = new GroupModelDto {
ID = 1, GroupName = "test"
};
SampleProfile = new ProfileModelDto {
ID = 1, LoginName = "test"
};
SampleGroupList = new List <GroupModelDto>
{
new GroupModelDto(),
new GroupModelDto()
};
}
public MembershipCreateStatus CreateUser(string userName, string password, string email)
{
try
{
var profile = new ProfileModelDto { LoginName = userName, Email = email, Role = "basicuser" };
AddProfile(profile);
UpdateRole(profile, false);
MembershipCreateStatus status;
if (Membership.Provider.RequiresQuestionAndAnswer)
Membership.Provider.CreateUser(profile.LoginName, password, email, "this is sample question", "this is answer", true, null, out status);
else
Membership.Provider.CreateUser(profile.LoginName, password, email, null, null, true, null, out status);
return status;
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.CreateUser - {0}", ex.Message);
return MembershipCreateStatus.ProviderError;
}
}
public void Can_add_profile()
{
#region Arrange
var profile = new ProfileModelDto { LoginName = "new profile", Email = "*****@*****.**" };
#endregion
#region Act
int id = new ProfileService().AddProfile(profile);
ProfileModel profileModel = null;
DataAccess.InTransaction(session =>
{
profileModel = session.Get<ProfileModel>(id);
});
#endregion
#region Assert
Assert.That(id,Is.GreaterThan(-1));
Assert.That(profileModel,Is.Not.Null);
Assert.That(profileModel.LoginName, Is.EqualTo("new profile"));
#endregion
}
public void Can_convert_entity_to_form_collection()
{
#region Arrange
var profile = new ProfileModelDto { Email = "*****@*****.**", ID = 1, IsActive = true,DisplayName="test", LoginName = "test", Role = "test" };
#endregion
#region Act
var form = TestHelper.ConvertEntityToFormCollection(profile);
#endregion
#region Assert
Assert.That(form.Count,Is.EqualTo(6));
Assert.That(form["Email"], Is.EqualTo("*****@*****.**"));
Assert.That(form["IsActive"], Is.EqualTo("True"));
Assert.That(form["LoginName"], Is.EqualTo("test"));
Assert.That(form["DisplayName"], Is.EqualTo("test"));
Assert.That(form["ID"], Is.EqualTo("1"));
Assert.That(form["Role"], Is.EqualTo("test"));
#endregion
}
public void Can_convert_entity_to_form_collection()
{
#region Arrange
var profile = new ProfileModelDto {
Email = "*****@*****.**", ID = 1, IsActive = true, DisplayName = "test", LoginName = "test", Role = "test"
};
#endregion
#region Act
var form = TestHelper.ConvertEntityToFormCollection(profile);
#endregion
#region Assert
Assert.That(form.Count, Is.EqualTo(6));
Assert.That(form["Email"], Is.EqualTo("*****@*****.**"));
Assert.That(form["IsActive"], Is.EqualTo("True"));
Assert.That(form["LoginName"], Is.EqualTo("test"));
Assert.That(form["DisplayName"], Is.EqualTo("test"));
Assert.That(form["ID"], Is.EqualTo("1"));
Assert.That(form["Role"], Is.EqualTo("test"));
#endregion
}
public void Can_add_profile()
{
#region Arrange
var profile = new ProfileModelDto {
LoginName = "new profile", Email = "*****@*****.**"
};
#endregion
#region Act
int id = new ProfileService().AddProfile(profile);
ProfileModel profileModel = null;
DataAccess.InTransaction(session =>
{
profileModel = session.Get <ProfileModel>(id);
});
#endregion
#region Assert
Assert.That(id, Is.GreaterThan(-1));
Assert.That(profileModel, Is.Not.Null);
Assert.That(profileModel.LoginName, Is.EqualTo("new profile"));
#endregion
}
public void Can_update_test()
{
#region Arrange
var test = new TestDto {
Author = ProfileModelDto.Map(TestPofile), CreationDate = DateTime.Now, Name = "new test", TestType = TestTypeModelDto.Map(TestTestType)
};
using (var session = DataAccess.OpenSession())
{
var course = session.Get <CourseModel>(1);
course.Tests.Add(TestDto.UnMap(test));
session.Flush();
}
using (var session = DataAccess.OpenSession())
{
var course = session.Get <CourseModel>(1);
Assert.That(course.Tests[0].Name, Is.EqualTo("new test"));
test.ID = course.Tests[0].ID;
}
#endregion
#region Act
test.Name = "updated test";
bool updateOk = new TestService().UpdateTest(test);
#endregion
#region Assert
using (var session = DataAccess.OpenSession())
{
var course = session.Get <CourseModel>(1);
Assert.That(course.Tests[0].Name, Is.EqualTo("updated test"));
Assert.That(updateOk, Is.True);
}
#endregion
}
public bool UpdateRole(ProfileModelDto profile,bool createIfNotExist)
{
var role = profile.Role;
var userName = profile.LoginName;
try
{
if (!String.IsNullOrWhiteSpace(role))
{
if (_roleProvider.RoleExists(role) && !_roleProvider.IsUserInRole(userName, role))
{
DeleteUserFromRoles(userName);
_roleProvider.AddUserToRole(userName, role);
}
else if (!_roleProvider.RoleExists(role) && createIfNotExist)
{
_roleProvider.CreateRole(role);
DeleteUserFromRoles(userName);
_roleProvider.AddUserToRole(userName, role);
}
}
else
{
DeleteUserFromRoles(userName);
}
return true;
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.UpdateRole - {0}", ex.Message);
return false;
}
}
public MembershipCreateStatus CreateUser(string userName, string password, string email)
{
try
{
var profile = new ProfileModelDto { LoginName = userName, Email = email, Role = "basicuser" };
AddProfile(profile);
UpdateRole(profile, false);
MembershipCreateStatus status;
if (Membership.Provider.RequiresQuestionAndAnswer)
Membership.Provider.CreateUser(profile.LoginName, password, email, "this is sample question", "this is answer", true, null, out status);
else
Membership.Provider.CreateUser(profile.LoginName, password, email, null, null, true, null, out status);
return status;
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.CreateUser - {0}", ex.Message);
return MembershipCreateStatus.ProviderError;
}
}
public void If_no_role_dont_update()
{
#region Arrange
var roleProvider = _mocker.DynamicMock<IRoleProvider>();
var profile = new ProfileModelDto { Role = "admin", LoginName = "user" };
var service = new ProfileService(roleProvider);
#endregion
#region Act
using (_mocker.Record())
{
Expect.Call(roleProvider.RoleExists("admin")).Return(false);
Expect.Call(() => roleProvider.AddUserToRole("user", "admin")).Repeat.Never();
Expect.Call(() => roleProvider.RemoveUserFromRole("user", "unusedRole")).Repeat.Never().IgnoreArguments();
}
using (_mocker.Playback())
{
service.UpdateRole(profile, false);
}
#endregion
}
public void If_role_parameter_empty_reset_user_roles()
{
#region Arrange
var roleProvider = _mocker.DynamicMock<IRoleProvider>();
var profile = new ProfileModelDto { Role = "", LoginName = "user" };
var service = new ProfileService(roleProvider);
#endregion
#region Act
using (_mocker.Record())
{
Expect.Call(roleProvider.GetRolesForUser("user")).Return(new[] { "unusedRole" });
Expect.Call(() => roleProvider.RemoveUserFromRole("user", "unusedRole"));
}
using (_mocker.Playback())
{
service.UpdateRole(profile, false);
}
#endregion
}
public bool UpdateProfile(ProfileModelDto profile)
{
try
{
DataAccess.InTransaction(session => session.Update(ProfileModelDto.UnMap(profile)));
return true;
}
catch (Exception ex)
{
Logger.Error("Error : ProfileService.UpdateProfile - {0}", ex.Message);
return false;
}
}
public void Updates_role_deletes_user_from_existing_roles()
{
#region Arrange
var roleProvider = _mocker.DynamicMock<IRoleProvider>();
var profile = new ProfileModelDto { Role = "admin", LoginName = "user" };
var service = new ProfileService(roleProvider);
#endregion
#region Act
using (_mocker.Record())
{
Expect.Call(roleProvider.RoleExists("admin")).Return(true);
Expect.Call(roleProvider.IsUserInRole("user", "admin")).Return(false);
Expect.Call(roleProvider.GetRolesForUser("user")).Return(new[] { "unusedRole" });
Expect.Call(() => roleProvider.RemoveUserFromRole("user", "unusedRole")).Repeat.Once();
Expect.Call(() => roleProvider.AddUserToRole("user", "admin"));
}
using (_mocker.Playback())
{
service.UpdateRole(profile, false);
}
#endregion
#region Assert
#endregion
}
