public void TestMethod1()
{
string username = "******";
var listofpermission = new List<string> { "ReadAll", "WriteAll", "DeleteAll" };
var role1 = new Role { Name = "administrator", Permissions = listofpermission };
var roles = new List<Role> { role1 };
string[] repositorytestrole = new string[] { "administrator" };
string repositorytestusername = "******";
string repositorytestpassword = "******";
int value = 1;
string repositorytestmark = "CBR600RR";
string repositorytestmanufacturer = "HONDA";
var repositorytestbikeyear = new DateTime(2000, 1, 1);
string repositorytestcondition = "normal_for_test";
//configuring userrepository mock
var userrepository = new Mock<IUserRepository>();
userrepository.Setup(m => m.GetUser(repositorytestusername, repositorytestpassword)).Returns(new User { Username = repositorytestusername, Roles = roles });
userrepository.Setup(m => m.RetrieveAllUsers()).Returns(new List<User> { new User { Username = repositorytestusername, Roles = roles } });
userrepository.Setup(m => m.GetAllUsers()).Returns(new List<User> { new User { Username = repositorytestusername, Roles = roles } });
userrepository.Setup(m => m.GetUserIDbyUsername(username)).Returns(value);
userrepository.Setup(m => m.GetUserIDbyUsername(repositorytestusername)).Returns(2);
userrepository.Setup(m => m.SaveNewUser(repositorytestusername, repositorytestpassword, repositorytestrole)).Returns(true);
//configuring bikerepository mock
var bikerepository = new Mock<IBikeRepository>();
var currentbike = new Bike
{
Manufacturer = repositorytestmanufacturer,
Mark = repositorytestmark,
BikeYear = repositorytestbikeyear,
ConditionState = repositorytestcondition,
OwnerID = 1
};
bikerepository.Setup(m => m.RetrieveAllBikes()).Returns(new List<Bike> { currentbike });
bikerepository.Setup(m => m.Search(repositorytestusername)).Returns(new List<Bike> { currentbike });
//configuring repository factory mock object in all repositories
var repositoryfactory = new Mock<IRepositoryFactory>();
repositoryfactory.Setup(m => m.GetUserRepository()).Returns(userrepository.Object);
repositoryfactory.Setup(m => m.GetBikeRepository()).Returns(bikerepository.Object);
//Start Domain and Services testing with Repository isolation.
ServiceLocator.RegisterService<IUserService>(typeof(UserService));
//Service->RepositoryFactory->Mock Object
Training.Workshop.Data.Context.Current.RepositoryFactory = repositoryfactory.Object;
var user = User.Create(repositorytestusername, repositorytestpassword, repositorytestrole);
Assert.IsTrue(user.Username == repositorytestusername);
Assert.IsTrue(user.Roles == roles);
//Stop userrepository testing
//Start bikerepository testing
ServiceLocator.RegisterService<IBikeService>(typeof(BikeService));
var bike1 = Bike.Create(repositorytestmanufacturer, repositorytestmark, repositorytestusername, value, repositorytestcondition);
Assert.IsTrue
(
bike1.Manufacturer == repositorytestmanufacturer &&
bike1.Mark == repositorytestmark &&
bike1.OwnerID == 2 &&
bike1.ConditionState == repositorytestcondition
);
var bike2 = Bike.Create(repositorytestmark, repositorytestmanufacturer, repositorytestusername, value, repositorytestcondition);
Assert.IsFalse
(
bike2.Manufacturer == repositorytestmanufacturer &&
bike2.Mark == repositorytestmark &&
bike2.OwnerID == value &&
bike2.ConditionState == repositorytestcondition
);
//Stop bikerepository testing
//Domain testing with service mock.
//cunfiguring services
var iuserservice = new Mock<IUserService>();
string newusername = "******";
iuserservice.Setup(m => m.GetUser(newusername, newusername)).Returns(new User { Username = newusername, Roles = roles });
iuserservice.Setup(m => m.Create("newuser", "newuser", repositorytestrole)).Returns(new User { Username = "******", Roles = roles });
iuserservice.Setup(m => m.Create("newuser2", "newuser2", repositorytestrole)).Returns(new User { Username = "******", Roles = roles });
//right choise
iuserservice.Setup(m => m.GetUser(newusername, newusername)).Returns(new User { Username = "******", Roles = roles });
//right
userrepository.Setup(m => m.GetUser(newusername, newusername)).Returns(new User { Username = newusername, Roles = roles });
userrepository.Setup(m => m.SaveNewUser("newuser", "newuser", repositorytestrole)).Returns(false);
userrepository.Setup(m => m.SaveNewUser(newusername, newusername, repositorytestrole)).Returns(true);
//Start Domain testing
//uncorrect SaveNewUser(username,password,roles),uncorrect data in User
var newuser1 = User.Create("newuser", "newuser", repositorytestrole);
Assert.IsFalse
(
newuser1.Username == newusername &&
newuser1.Roles == roles
);
//correct SaveNewUser(), correct data in User
var newuser2 = User.Create(newusername, newusername, repositorytestrole);
userrepository.Setup(m => m.SaveNewUser(newusername, newusername, repositorytestrole)).Returns(true);
Assert.IsTrue
(
newuser2.Username == newusername &&
newuser2.Roles == roles
);
//uncorrect SaveNewUser(), correct data in User
var newuser3 = User.Create("newuser2", "newuser2", repositorytestrole);
Assert.IsFalse
(
newuser3.Username == newusername &&
newuser3.Roles == roles
);
//Stop Domain testing
}
/// <summary>
/// Returns all users with permissions and roles.
/// New method works with 1 stored procedure.
/// </summary>
/// <returns></returns>
public List<User> RetrieveAllUsers()
{
var listofusers = new List<User>();
using (var unitofwork = (ISQLUnitOfWork)Training.Workshop.UnitOfWork.UnitOfWork.Start())
{
using (var command = unitofwork.Connection.CreateCommand())
{
command.CommandText = "usp_GetAllUsers";
command.CommandType = CommandType.StoredProcedure;
using (IDataReader reader = command.ExecuteReader())
{
//UserID,Username
List<Tuple<string, string>> userlist = GetUser(reader);
if (!reader.NextResult())
throw new InvalidOperationException("Cant execute SELECT ROLES");
//UserID,RoleID,RoleName
List<Tuple<string, string, string>> roleslist = GetRoles(reader);
if (!reader.NextResult())
throw new InvalidOperationException("Cant execute SELECT PERMISSIONS");
// Get Permissions by username
List<Tuple<string, string, string>> permissionslist = GetPermissions(reader);
reader.Close();
//filled user fields before return.
foreach (var userelement in userlist)
{
var newuser = new User();
var userid = userelement.Item1;
newuser.Username = userelement.Item2.ToString();
var rolelist = new List<Role>();
foreach (var roleelement in roleslist)
{
var role = new Role();
if (userid == roleelement.Item1)
{
role.Name = roleelement.Item3;
var Permissionlist = new List<string>();
foreach (var permissionelement in permissionslist)
{
//if permission relates to role-adding permission to list belongs to role.
if (roleelement.Item2 == permissionelement.Item2)
{
{
Permissionlist.Add(permissionelement.Item3.ToString());
}
}
}
//adding all permissions to role
role.Permissions = Permissionlist;
//adding role to role list of user
rolelist.Add(role);
}
}
newuser.Roles = rolelist;
listofusers.Add(newuser);
}
}
}
}
return listofusers;
}
/// <summary>
/// Get User with roles and permissions by one stored procedure
/// </summary>
/// <param name="username"></param>
/// <returns></returns>
public User RetrieveUser(string username)
{
//User Construction
var user = new User();
using (var unitofwork = (ISQLUnitOfWork)Training.Workshop.UnitOfWork.UnitOfWork.Start())
{
using (var command = unitofwork.Connection.CreateCommand())
{
command.CommandText = "usp_GetUser";
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("Username", username);
using (IDataReader reader = command.ExecuteReader())
{
//UserID,Username
List<Tuple<string, string>> userlist = GetUser(reader);
//to search roles and permissions by userID
string userID = userlist[0].Item1;
if (!reader.NextResult())
throw new InvalidOperationException("Cant execute SELECT ROLES");
//UserID,RoleID,RoleName
List<Tuple<string, string, string>> roleslist = GetRoles(reader,userID);
if (!reader.NextResult())
throw new InvalidOperationException("Cant execute SELECT PERMISSIONS");
// Get Permissions by username
//UserID,RoleID,Permission
List<Tuple<string, string, string>> permissionslist = GetPermissions(reader,userID);
reader.Close();
//filled user role and permissions before return.
user.Username = username;
var rolelist=new List<Role>();
foreach (var roleelement in roleslist)
{
var role = new Role();
role.Name = roleelement.Item3.ToString();
var Permissionlist = new List<string>();
foreach (var permissionelement in permissionslist)
{
//if permission relates to role-adding permission to list belongs to role.
if (roleelement.Item2.ToString() == permissionelement.Item2.ToString())
{
Permissionlist.Add(permissionelement.Item3.ToString());
}
}
//adding all permissions to role
role.Permissions = Permissionlist;
//adding role to role list of user
rolelist.Add(role);
}
user.Roles = rolelist;
}
}
}
return user;
}
/// <summary>
/// return all obtained User Roles by username and fill it by permissions,return List of Roles with all permissions.
/// </summary>
/// <param name="username"></param>
/// <returns></returns>
public List<Role> GetRolesandPermissionsbyUsername(string username)
{
List<string> RoleNamesListwhichUserhas = Data.Context.Current.RepositoryFactory.GetUserRepository().GetRoleNamesByUsername(username);
var RoleList = new List<Role>();
foreach (var role in RoleNamesListwhichUserhas)
{
var Role = new Role()
{
Name = role,
Permissions = GetPermissionsbyRolename(role)
};
RoleList.Add(Role);
}
return RoleList;
}
