public void Map_Test()
{
#region === ARRANGE ===
SessionToken token = new SessionToken
{
userId = 555,
userName = "******"
};
SessionTokenToUserAppModelMapper mapper = new SessionTokenToUserAppModelMapper();
#endregion
#region === ACT ===
UserAppModel result = mapper.Map(token);
#endregion
#region === ASSERT ===
Assert.AreEqual <int>(token.userId, result.id);
Assert.AreEqual <string>(token.userName, result.username);
Assert.AreEqual <bool>(true, result.active);
#endregion
}
public void GenerateToken_Test()
{
#region === ARRANGE ===
UserAppModel user = new UserAppModel
{
id = 999,
username = "******",
active = true
};
Mock <IRepositoryFactory> mockRepositoryFactory = new Mock <IRepositoryFactory>();
Mock <IReadOnlyRepository <DtoConfiguration> > mockConfigurationRepository = new Mock <IReadOnlyRepository <DtoConfiguration> >();
Mock <ISessionTokenGenerator> mockSessionTokenGenerator = new Mock <ISessionTokenGenerator>();
mockRepositoryFactory.Setup(x => x.CreateReadOnlyConfigurationsRepository()).Returns(mockConfigurationRepository.Object);
mockConfigurationRepository.Setup(x => x.GetAll()).Returns(new DtoConfiguration[] { new DtoConfiguration(1, "tokenEncriptKey", "Bla Bla") });
mockSessionTokenGenerator.Setup(x => x.Encript(It.IsAny <SessionToken>())).Returns("Some Encripted Token");
#endregion
#region === ACT ===
SessionTokenService service = new SessionTokenService(mockRepositoryFactory.Object, mockSessionTokenGenerator.Object);
service.GenerateToken("Some UUID", user, false);
#endregion
#region === ASSERT ===
mockSessionTokenGenerator.Verify(x => x.Encript(It.IsAny <SessionToken>()), Times.Once);
#endregion
}
public void Invoke_ValidData_DeleteAndSaveAreCalled()
{
// prepare
var userAppToDelete = new UserAppModel()
{
Id = 1
};
var userAppFromDb = new List <DataAccess.Models.UserApps>()
{
new DataAccess.Models.UserApps()
{
Id = 1,
App = new DataAccess.Models.App()
{
Id = 123
}
}
};
var mockedUserAppRepository = new Mock <IUserAppRepository>();
mockedUserAppRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserApps, bool> > >()))
.Returns(userAppFromDb.AsQueryable());
// action
var action = new DeleteUserApp(mockedUserAppRepository.Object);
var actionResult = action.Invoke(userAppToDelete.Id, 123);
// assert
Assert.True(actionResult);
mockedUserAppRepository.Verify(r => r.Delete(It.IsAny <DataAccess.Models.UserApps>()), Times.Once());
mockedUserAppRepository.Verify(r => r.Save(), Times.Once());
}
public void GetUser_Test()
{
#region === ARRANGE ===
Mock <IReadOnlyRepository <DtoUser> > mockReadOnlyRepository = new Mock <IReadOnlyRepository <DtoUser> >();
Mock <IRepositoryFactory> mockRepositoryFactory = new Mock <IRepositoryFactory>();
mockReadOnlyRepository.Setup(x => x.Get(It.IsAny <int>())).Returns(new DtoUser(999, "", "", false));
mockRepositoryFactory.Setup(x => x.CreateReadOnlyUsersRepository()).Returns(mockReadOnlyRepository.Object);
UserQueriesService userQueriesService = new UserQueriesService(mockRepositoryFactory.Object);
#endregion
#region === ACT ===
UserAppModel user = userQueriesService.GetUser(999);
#endregion
#region === ASSERT ===
mockReadOnlyRepository.Verify(x => x.Get(It.IsAny <int>()), Times.Once);
Assert.AreEqual <int>(999, user.id);
#endregion
}
//Working
public List <UserAppModel> GetAllUserAppsDistinct()
{
List <UserAppModel> list = new List <UserAppModel>();
using (MyDbContext _db = new MyDbContext())
{
try
{
var distinctBlazerIds = _db.UserApps.GroupBy(x => x.BlazerId).Select(x => x.FirstOrDefault()).ToList();
foreach (var item in distinctBlazerIds)
{
var userAppModel = new UserAppModel
{
BlazerId = item.BlazerId,
AppCount = _db.UserApps.Count(x => x.BlazerId == item.BlazerId)
};
list.Add(userAppModel);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(list);
}
}
private void btnSearch_Click(object sender, RoutedEventArgs e)
{
int id = -1;
try
{
id = int.Parse(searchMe.Text);
}
catch
{
MessageBox.Show("Enter positive number", "Wrong input in search box");
}
try
{
User u = _proxy.FindUserByID(id);
if (u != null)
{
_user = _mapper.Map(u, new UserAppModel());
SetTextBoxes();
usersTable.SelectedItem = _user;
}
else
{
MessageBox.Show("I can't find user with ID: " + id, "Cannot find user");
}
}
catch (InvalidOperationException)
{
MessageBox.Show("I can't find user with ID: " + id, "Cannot find user");
}
}
public void Get_ById_Test()
{
#region === ARRANGE ===
Mock <IApplicationServicesFactory> mockApplicationServicesFactory = new Mock <IApplicationServicesFactory>();
Mock <IUserQueriesService> mockUserQueriesService = new Mock <IUserQueriesService>();
Mock <ILogger <AccountsController> > mockLoger = new Mock <ILogger <AccountsController> >();
AccountsController usersController = new AccountsController(mockLoger.Object, mockApplicationServicesFactory.Object);
UserAppModel userAppModel = new UserAppModel()
{
id = 55, active = true, username = "******"
};
mockApplicationServicesFactory.Setup(x => x.CreateUserQueriesService()).Returns(mockUserQueriesService.Object);
mockUserQueriesService.Setup(x => x.GetUser(It.IsAny <int>())).Returns(userAppModel);
#endregion
#region === ACT ===
var result = usersController.Get(55);
#endregion
#region === ASSERT ===
Assert.AreEqual <int>(userAppModel.id, result.id);
Assert.AreEqual <bool>(userAppModel.active, result.active);
Assert.AreEqual <string>(userAppModel.username, result.username);
#endregion
}
public bool Invoke(int appId, int user, UserRole newRole)
{
var userFromDB = userRepository.GetById(user);
if (userFromDB == null || userFromDB.IsSuperAdmin && newRole == UserRole.SuperAdmin)
{
return(false);
}
var userApp = userAppRepository.FindBy(m => m.User.Id == user && m.App.Id == appId).FirstOrDefault();
if (userApp == null && !userFromDB.IsSuperAdmin)
{
return(false);
}
if (userApp == null && userFromDB.IsSuperAdmin)
{
// Set IsSuperAdmin flag to false
userFromDB.IsSuperAdmin = false;
userRepository.Edit(userFromDB);
userRepository.Save();
// Add new user to this app with newRole
var newUserApp = new UserAppModel
{
AppId = appId,
UserId = user,
Role = newRole
};
addNewUserApp.Invoke(newUserApp);
return(true);
}
var userRole = (UserRole)userApp.Role;
if (userRole.Equals(newRole) || newRole > userRole)
{
if (!userFromDB.IsSuperAdmin)
{
return(false);
}
// Set IsSuperAdmin flag to false
userFromDB.IsSuperAdmin = false;
userRepository.Edit(userFromDB);
userRepository.Save();
return(true);
}
userApp.Role = (DataAccess.Enums.UserRole)newRole;
userAppRepository.Edit(userApp);
userAppRepository.Save();
return(true);
}
private void usersTable_CurrentCellChanged(object sender, EventArgs e)
{
try
{
_user = _mapper.Map(usersTable.SelectedItem, new UserAppModel());
SetTextBoxes();
}
catch
{
}
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
// we will have User authenticated by app.UseJwtBearerAuthentication(...)
var user = ((ControllerBase)context.Controller).User;
if (user != null && user.Identity.IsAuthenticated)
{
LoggedUser = new UserAppModel();
// convert security claims to our custom user data
LoggedUser.FillFromClaims(user.Claims);
}
}
public string GenerateToken(string UUID, UserAppModel userModel, bool isExpirable)
{
int daysToExpire = isExpirable ? 1 : 0;
SessionToken token = new SessionToken
{
UUID = UUID,
daysToExpire = daysToExpire,
userId = userModel.id,
userName = userModel.username,
dateTime = DateTime.Now
};
return(tokenGenerator.Encript(token));
}
public void OnAuthorization_Test_DontNeedToken()
{
#region === ARRANGE ===
Mock <IList <IFilterMetadata> > mockListIFilterMetadata = new Mock <IList <IFilterMetadata> >();
Mock <HttpRequest> mockRequest = new Mock <HttpRequest>();
Mock <IHeaderDictionary> mockHeaders = new Mock <IHeaderDictionary>();
mockRequest.SetupGet(x => x.Headers).Returns(
new HeaderDictionary {
{ "UUID", "Some UUID" }
}
);
Mock <HttpContext> mockContext = new Mock <HttpContext>();
mockContext.SetupGet(x => x.Request).Returns(mockRequest.Object);
Mock <IApplicationServicesFactory> mockApplicationServicesFactory = new Mock <IApplicationServicesFactory>();
Mock <ISessionTokenService> mockSessionTokenService = new Mock <ISessionTokenService>();
BaseAuthorizeAttribute baseAuthorizeAttribute = new BaseAuthorizeAttribute(mockApplicationServicesFactory.Object)
{
dontNeedToken = true
};
UserAppModel userAppModel = new UserAppModel()
{
id = 55, active = true, username = "******"
};
mockSessionTokenService.Setup(x => x.DecryptToken(It.IsAny <string>(), It.IsAny <string>())).Returns(userAppModel);
mockApplicationServicesFactory.Setup(x => x.CreateSessionTokenService()).Returns(mockSessionTokenService.Object);
ActionContext actionContext = new ActionContext(mockContext.Object, new RouteData(), new ControllerActionDescriptor());
#endregion
#region === ACT ===
AuthorizationFilterContext authorizationFilterContext = new AuthorizationFilterContext(actionContext, mockListIFilterMetadata.Object);
baseAuthorizeAttribute.OnAuthorization(authorizationFilterContext);
#endregion
#region === ASSERT ===
Assert.IsNotInstanceOfType(authorizationFilterContext.Result, typeof(UnauthorizedResult));
#endregion
}
public Users()
{
InitializeComponent();
_proxy = new UserServiceClient("UserServiceTcpEndpoint");
var config = new MapperConfiguration(cfg => {
cfg.CreateMap <UserAppModel, User>();
});
_mapper = config.CreateMapper();
_user = new UserAppModel();
Init();
GetAll();
}
public void NewToken_test()
{
#region === ARRANGE ===
Mock <HttpRequest> mockRequest = new Mock <HttpRequest>();
Mock <IHeaderDictionary> mockHeaders = new Mock <IHeaderDictionary>();
mockRequest.SetupGet(x => x.Headers).Returns(
new HeaderDictionary {
{ "UUID", "Some UUID" }
}
);
Mock <HttpContext> mockContext = new Mock <HttpContext>();
mockContext.SetupGet(x => x.Request).Returns(mockRequest.Object);
Mock <IApplicationServicesFactory> mockApplicationServicesFactory = new Mock <IApplicationServicesFactory>();
Mock <IRepositoryFactory> mockRepositoryFactory = new Mock <IRepositoryFactory>();
Mock <IReadOnlyRepository <DtoConfiguration> > mockReadOnlyRepository = new Mock <IReadOnlyRepository <DtoConfiguration> >();
Mock <ILogger <SessionController> > mockLoger = new Mock <ILogger <SessionController> >();
SessionController sessionController = new SessionController(mockLoger.Object, mockApplicationServicesFactory.Object);
UserAppModel userAppModel = new UserAppModel()
{
id = 55, active = true, username = "******"
};
mockRepositoryFactory.Setup(x => x.CreateReadOnlyConfigurationsRepository()).Returns(mockReadOnlyRepository.Object);
mockReadOnlyRepository.Setup(x => x.GetAll()).Returns(new DtoConfiguration[] { new DtoConfiguration(1, "tokenEncriptKey", "ABC") });
mockApplicationServicesFactory.Setup(x => x.CreateSessionTokenService()).Returns(new SessionTokenService(mockRepositoryFactory.Object));
sessionController.ControllerContext = new ControllerContext(new ActionContext(mockContext.Object, new RouteData(), new ControllerActionDescriptor()));
#endregion
#region === ACT ===
string result = sessionController.NewToken();
#endregion
#region === ASSERT ===
Assert.AreNotEqual(true, string.IsNullOrEmpty(result));
#endregion
}
public IActionResult AddUser(AppUserViewModel appuser)
{
if (!ModelState.IsValid)
{
Alert.Warning();
}
var newAppuser = new UserAppModel
{
AppId = appuser.AppId,
UserId = appuser.UserId,
Role = appuser.Role
};
addUserApp.Invoke(newAppuser);
return(RedirectToAction("Details", new { id = appuser.AppId }));
}
public void OnAuthorization(AuthorizationFilterContext context)
{
if (!string.IsNullOrEmpty(context.HttpContext.Request.Headers["UUID"]) && !string.IsNullOrEmpty(context.HttpContext.Request.Headers["Token"]))
{
string uuid = context.HttpContext.Request.Headers["UUID"];
string tokenString = context.HttpContext.Request.Headers["Token"];
ISessionTokenService sessionTokenService = servicesFactory.CreateSessionTokenService();
UserAppModel user = sessionTokenService.DecryptToken(uuid, tokenString);
if (user != null && user.id > 0)
{
return;
}
}
context.Result = new UnauthorizedResult();
return;
}
public void Invoke_AlreadyExists_AddNorSaveAreCalled()
{
// prepare
var userAppToAdd = new UserAppModel()
{
AppId = 1,
UserId = 1,
Role = Enums.UserRole.SuperAdmin
};
var userAppFromDb = new DataAccess.Models.UserApps()
{
App = new DataAccess.Models.App()
{
Id = 1
},
User = new DataAccess.Models.User()
{
Id = 1
},
Role = DataAccess.Enums.UserRole.SuperAdmin
};
var findByResult = new List <DataAccess.Models.UserApps>()
{
userAppFromDb
};
var mockedUserRepository = new Mock <IUserRepository>();
var mockedAppRepository = new Mock <IAppRepository>();
var mockedUserAppRepository = new Mock <IUserAppRepository>();
mockedUserAppRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserApps, bool> > >()))
.Returns(findByResult.AsQueryable);
var action = new AddNewUserApp(mockedUserAppRepository.Object, mockedUserRepository.Object,
mockedAppRepository.Object);
// action
var actionResult = action.Invoke(userAppToAdd);
// assert
Assert.Equal(0, actionResult);
mockedUserAppRepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.UserApps>()), Times.Never);
mockedUserAppRepository.Verify(r => r.Save(), Times.Never);
}
public void Invoke_InvalidData_AddNorSaveAreCalled()
{
// prepare
var userAppToAdd = new UserAppModel();
var mockedUserRepository = new Mock <IUserRepository>();
var mockedAppRepository = new Mock <IAppRepository>();
var mockedUserAppRepository = new Mock <IUserAppRepository>();
var action = new AddNewUserApp(mockedUserAppRepository.Object, mockedUserRepository.Object,
mockedAppRepository.Object);
// action
var actionResult = action.Invoke(userAppToAdd);
// assert
Assert.Equal(0, actionResult);
mockedUserAppRepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.UserApps>()), Times.Never);
mockedUserAppRepository.Verify(r => r.Save(), Times.Never);
}
public void Invoke_ValidData_AddAndSaveAreCalled()
{
// prepare
var user = new DataAccess.Models.User()
{
Id = 1,
Email = "test"
};
var app = new DataAccess.Models.App()
{
Id = 1,
Name = "test"
};
var userAppToAdd = new UserAppModel()
{
AppId = 1,
UserId = 1,
Role = Enums.UserRole.SuperAdmin
};
var mockedUserRepository = new Mock <IUserRepository>();
var mockedAppRepository = new Mock <IAppRepository>();
var mockedUserAppRepository = new Mock <IUserAppRepository>();
mockedUserRepository.Setup(r => r.GetById(userAppToAdd.UserId))
.Returns(user);
mockedAppRepository.Setup(r => r.GetById(userAppToAdd.AppId))
.Returns(app);
var action = new AddNewUserApp(mockedUserAppRepository.Object, mockedUserRepository.Object,
mockedAppRepository.Object);
// action
action.Invoke(userAppToAdd);
// assert
mockedUserAppRepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.UserApps>()), Times.Once());
mockedUserAppRepository.Verify(r => r.Save(), Times.Once());
}
public int Invoke(UserAppModel model)
{
var userApp = new DataAccess.Models.UserApps()
{
User = userRepository.GetById(model.UserId),
App = appRepository.GetById(model.AppId),
Role = (DataAccess.Enums.UserRole)Enum.Parse(typeof(DataAccess.Enums.UserRole), model.Role.ToString()),
};
if (userApp.User == null ||
userApp.App == null ||
userAppRepository.FindBy(x => x.App.Id == userApp.App.Id && x.User.Id == userApp.User.Id).Any())
{
return(0);
}
userAppRepository.Add(userApp);
userAppRepository.Save();
return(userApp.Id);
}
public void Invoke_ForNullUserApps_DeleteNorSaveAreCalled()
{
// prepare
var userAppToDelete = new UserAppModel()
{
Id = 1
};
var userAppFromDb = new List <DataAccess.Models.UserApps>();
var mockedUserAppRepository = new Mock <IUserAppRepository>();
mockedUserAppRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserApps, bool> > >()))
.Returns(userAppFromDb.AsQueryable());
var action = new DeleteUserApp(mockedUserAppRepository.Object);
var actionResult = action.Invoke(userAppToDelete.Id, 5);
Assert.False(actionResult);
mockedUserAppRepository.Verify(r => r.Delete(It.IsAny <DataAccess.Models.UserApps>()), Times.Never);
mockedUserAppRepository.Verify(r => r.Save(), Times.Never);
}
public void DecryptToken_Test()
{
#region === ARRANGE ===
SessionToken expectedToken = new SessionToken
{
userId = 999,
userName = "******",
dateTime = DateTime.Now,
daysToExpire = 0,
UUID = "Some UUID"
};
Mock <IRepositoryFactory> mockRepositoryFactory = new Mock <IRepositoryFactory>();
Mock <IReadOnlyRepository <DtoConfiguration> > mockConfigurationRepository = new Mock <IReadOnlyRepository <DtoConfiguration> >();
Mock <ISessionTokenGenerator> mockSessionTokenGenerator = new Mock <ISessionTokenGenerator>();
mockRepositoryFactory.Setup(x => x.CreateReadOnlyConfigurationsRepository()).Returns(mockConfigurationRepository.Object);
mockConfigurationRepository.Setup(x => x.GetAll()).Returns(new DtoConfiguration[] { new DtoConfiguration(1, "tokenEncriptKey", "Bla Bla") });
mockSessionTokenGenerator.Setup(x => x.Decrypt(It.IsAny <string>())).Returns(expectedToken);
#endregion
#region === ACT ===
SessionTokenService service = new SessionTokenService(mockRepositoryFactory.Object, mockSessionTokenGenerator.Object);
UserAppModel userAppModel = service.DecryptToken(expectedToken.UUID, "some token string");
#endregion
#region === ASSERT ===
mockSessionTokenGenerator.Verify(x => x.Decrypt(It.IsAny <string>()), Times.Once);
Assert.AreEqual <int>(userAppModel.id, expectedToken.userId);
Assert.AreEqual <string>(userAppModel.username, expectedToken.userName);
#endregion
}
public void Map_Test()
{
#region === ARRANGE ===
DtoUser user = new DtoUser(777, "xpto", "hash", true);
DtoUserToUserAppModelMapper mapper = new DtoUserToUserAppModelMapper();
#endregion
#region === ACT ===
UserAppModel result = mapper.Map(user);
#endregion
#region === ASSERT ===
Assert.AreEqual <int>(user.ID, result.id);
Assert.AreEqual <string>(user.UserName, result.username);
Assert.AreEqual <bool>(user.Active, result.active);
#endregion
}
private void btnDelete_Click(object sender, RoutedEventArgs e)
{
UserAppModel user = (UserAppModel)usersTable.SelectedItem;
if (MessageBox.Show("Are you sure that you want to delete the user?",
"Confirmation", MessageBoxButton.YesNo,
MessageBoxImage.Warning) == MessageBoxResult.Yes)
{
var result = _proxy.DeleteUser(user.ID);
if (result)
{
GetAll();
}
else
{
MessageBox.Show("I can't delete the user.");
}
}
else
{
MessageBox.Show("I can't user with ID: " + _user.ID, "Cannot find user");
}
}
public void SeedUserApps(IAddNewUserApp addNewUserApps)
{
foreach (var user in users)
{
var model = new UserAppModel
{
AppId = context.Apps.OrderBy(r => Guid.NewGuid()).Take(1).FirstOrDefault().Id,
UserId = context.Users.FirstOrDefault(r => r.Name.Contains(user)).Id
};
switch (user)
{
case "manager":
model.Role = UserRole.Manager;
addNewUserApps.Invoke(model);
break;
case "user":
model.Role = UserRole.User;
addNewUserApps.Invoke(model);
break;
}
}
}
