public void ValidRegisterShouldCreateNewUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateNewUser))// "ValidRegisterShouldCreateNewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UserService(context, config);
var added = new RegisterUserPostDto
{
FullName = "fdsfsdfs",
Username = "******",
Email = "[email protected]",
Password = "******",
};
var result = usersService.Register(added);
Assert.IsNotNull(result);
Assert.AreEqual(added.Username, result.Username);
}
}
public IHttpActionResult Login(User user)
{
try
{
using (var db = new ExpensesDbContext())
{
var userExists = db.Users.Any(u => u.UserName == user.UserName && u.Password == user.Password);
if (userExists)
{
var token = CreateToken(user);
return(Ok(token));
}
return(BadRequest("username or password is not correct"));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ErrorsCollection Validate(PostUserDto postUserDto, ExpensesDbContext expensesDbContext)
{
ErrorsCollection errorsCollection = new ErrorsCollection {
Entity = nameof(postUserDto)
};
User existing = expensesDbContext.Users.FirstOrDefault(u => u.Username == postUserDto.Username);
if (existing != null)
{
errorsCollection.ErrorMessages.Add($"Username {postUserDto.Username} is already used!");
}
if (postUserDto.Password.Length < 6)
{
errorsCollection.ErrorMessages.Add("The password has to have > 5 chars");
}
int numberOfDigits = 0;
foreach (char c in postUserDto.Password)
{
if (c >= '0' && c <= '9')
{
numberOfDigits++;
}
}
if (numberOfDigits < 2)
{
errorsCollection.ErrorMessages.Add("The password must contain at least 2 digits");
}
if (errorsCollection.ErrorMessages.Count > 0)
{
return(errorsCollection);
}
return(null);
}
public void GetAllShouldReturnAllUserRoles()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllUserRoles))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userRoleService = new UserRoleService(context);
var addUserRole = new UserRolePostModel()
{
Name = "Newbegginer",
Description = "A role for a new guy..."
};
var current = userRoleService.Create(addUserRole);
var allUsers = userRoleService.GetAll();
Assert.IsNotNull(allUsers);
Assert.AreEqual(1, allUsers.Count());
}
}
public void GetByIdTest()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPages))
.Options;
using (var context = new ExpensesDbContext(options))
{
var commentService = new CommentService(context);
var expenseService = new ExpenseService(context);
var addedExpense = expenseService.Create(new Labo2.ViewModels.ExpensePostModel
{
Description = "description test",
Sum = 1.23,
Location = "cluj",
Date = new DateTime(),
Currency = "euro",
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "ddfgfgsrt",
AddedBy = null
}
},
}, null);
var addedComment = commentService.Create(new Labo2.ViewModels.CommentPostModel
{
Important = true,
Text = "asd",
}, addedExpense.Id);
var comment = commentService.GetById(addedComment.Id);
Assert.NotNull(comment);
}
}
public void ValidGetAll()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetAll))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, config);
var added = new Lab2Expense.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******"
};
var result = usersService.GetAll();
Assert.IsNotNull(result);
}
}
public void GetByIdShouldReturnAValidUser_UserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnAValidUser_UserRole))
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new UserRoleValidator();
User_UserRoleService user_userRoleService = new User_UserRoleService(validator, context);
var added = new Labo2.ViewModels.User_UserRolePostModel
{
UserId = 1,
UserRoleName = "Regular",
StartTime = DateTime.Now,
EndTime = null
};
var userById = user_userRoleService.GetById(added.UserId);
Assert.IsNotNull(userById);
}
}
public void ValidUpsertShouldModifyFieldsValues()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidUpsertShouldModifyFieldsValues))
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new RegisterValidator();
var crValidator = new CreateValidator();
var usersService = new UsersService(context, validator, crValidator, null, config);
var added = new Lab6.Viewmodels.UserPostModel
{
FirstName = "Nume",
LastName = "Prenume",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
usersService.Create(added);
var updated = new Lab6.Models.User
{
FirstName = "Alin",
LastName = "Popescu",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var userUpdated = usersService.Upsert(1, updated);
Assert.NotNull(userUpdated);
Assert.AreEqual("Alin", userUpdated.FirstName);
Assert.AreEqual("Popescu", userUpdated.LastName);
}
}
public void ValidDeleteIsRemovedShoulBeTrue()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidDeleteIsRemovedShoulBeTrue))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UsersService(context, config);
var added = new Lab2Expense.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******"
};
var resultAdded = usersService.Register(added);
var resultDelete = usersService.Delete(resultAdded.Id);
Assert.AreEqual(true, resultDelete.isRemoved);
}
}
public void GetByIdShouldReturnAValidUserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnAValidUserRole))
.Options;
using (var context = new ExpensesDbContext(options))
{
UserRoleService userRoleService = new UserRoleService(context);
var addUserRole = new UserRolePostModel()
{
Name = "NewUser",
Description = "New user added"
};
var current = userRoleService.Create(addUserRole);
var expected = userRoleService.GetById(current.Id);
Assert.IsNotNull(expected);
Assert.AreEqual(expected.Name, current.Name);
Assert.AreEqual(expected.Id, current.Id);
}
}
public void CreateShouldAddAndReturnTheCreatedUserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldAddAndReturnTheCreatedUserRole))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userRoleService = new UserRoleService(context);
var addUserRole = new UserRolePostModel()
{
Name = "Newbegginer",
Description = "A role for a new guy..."
};
var current = userRoleService.Create(addUserRole);
Assert.IsNotNull(current);
Assert.AreEqual("Newbegginer", current.Name);
}
}
public void ValidRegisterShouldCreateANewUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateANewUser))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UsersService(context, config);
var added = new Labo2.ViewModels.RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "User",
LastName = "Test",
Password = "******",
Username = "******"
};
var result = usersService.Register(added);
Assert.IsNotNull(result);
Assert.AreEqual(added.Username, result.Username);
}
}
public void GetAllShouldReturnCorrectNumberOfPages()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPages))
.Options;
using (var context = new ExpensesDbContext(options))
{
// var commentService = new CommentService(context);
var expenseService = new ExpenseService(context);
var addedFlower = expenseService.Create(new Lab2Expense.ViewModels.ExpensePostModel
{
Description = "jshdkhsakjd",
Sum = 1.23,
Location = "jsfkdsf",
Date = new DateTime(),
Currency = "euro",
ExpenseType = "food",
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "asd",
Owner = null
}
},
}, null);
var DateStart = new DateTime(2019, 05, 05, 12, 30, 00);
var DateEnd = new DateTime(2019, 07, 05, 12, 30, 00);
var ExpenseTypeFood = ExpenseType.food;
var allComments = expenseService.GetAll(1);
var allCommentsDateType = expenseService.GetAll(1, DateStart, DateEnd, ExpenseTypeFood);
Assert.NotNull(allCommentsDateType);
}
}
public void GetAllShouldReturnAllUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UserService(context, config);
var added1 = new RegisterUserPostDto
{
FullName = "codruta1",
Email = "*****@*****.**",
Username = "******",
Password = "******"
};
var added2 = new RegisterUserPostDto
{
FullName = "codruta3",
Email = "*****@*****.**",
Username = "******",
Password = "******"
};
usersService.Register(added1);
usersService.Register(added2);
int numberOfElements = usersService.GetAll().Count();
Assert.NotZero(numberOfElements);
}
}
public void DeleteExistingExpense()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteExistingExpense))
.Options;
using (var context = new ExpensesDbContext(options))
{
var expenseService = new ExpenseService(context);
User user = new User
{
Username = "******"
};
var result = new Lab2.DTOs.PostExpenseDto
{
//Added = DateTime.Now,
// Deadline = DateTime.Now.AddDays(15),
// ClosedAt = null,
Description = "Read1",
Sum = 3,
Location = "Read1",
Date = DateTime.Now.AddDays(15),
Currency = "ADF",
Type = "FOOD",
// ClosedAt = null,
// Importance = "Medium",
// State = "InProgress",
Comments = null
};
Expense saveexpense = expenseService.Create(result, user);
expenseService.Delete(saveexpense.Id);
Assert.IsNull(expenseService.GetById(saveexpense.Id));
}
}
public void ValidAuthenticationShouldAuthenticateValidUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidAuthenticationShouldAuthenticateValidUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userService = new UsersService(context, config);
var addedUser = new Laborator2.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "ddd",
LastName = "eee",
Password = "******",
Username = "******"
};
var addResult = userService.Register(addedUser);
Assert.IsNotNull(addResult);
Assert.AreEqual(addedUser.Username, addResult.Username);
var authenticate = new Laborator2.ViewModels.UserGetModel
{
Email = "[email protected]",
Username = "******"
};
var result = userService.Authenticate(addedUser.Username, addedUser.Password);
Assert.IsNotNull(result);
Assert.AreEqual(authenticate.Username, result.Username);
}
}
public void GetCurrentUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetCurrentUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var registervalidator = new RegisterValidator();
var validator = new UserRoleValidator();
var user_userRoleService = new User_UserRoleService(validator, context);
UsersService usersService = new UsersService(context, registervalidator, config, user_userRoleService);
//UsersController usersController = new UsersController(usersService, null);
//usersController.ControllerContext = new Microsoft.AspNetCore.Mvc.ControllerContext();
//usersController.ControllerContext.HttpContext = new DefaultHttpContext();
// usersController.ControllerContext.HttpContext.Items.Add("user-Name", "Ghita");
var added = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "User",
LastName = "Test",
Password = "******",
Username = "******"
};
var resultAdded = usersService.Register(added);
var resultAuthentificate = usersService.Authenticate(added.Username, added.Password);
var user = context.Users.FirstOrDefault(user_userRole => user_userRole.Id == resultAuthentificate.Id);
//User userRole = usersService.GetCurrentUser(user);
//Assert.IsNotNull(user);
//Assert.AreEqual(resultAuthentificate, userRole.Id);
}
}
public void GetAllShouldReturnAllRegisteredUsers()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllRegisteredUsers))
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new UserRoleValidator();
var user_userRoleService = new User_UserRoleService(validator, context);
var registerValidator = new RegisterValidator();
var usersService = new UsersService(context, registerValidator, config, user_userRoleService);
var added = new RegisterPostModel()
{
FirstName = "User",
LastName = "Test",
Username = "******",
Email = "*****@*****.**",
Password = "******",
};
var added2 = new RegisterPostModel()
{
FirstName = "User2",
LastName = "Test2",
Username = "******",
Email = "*****@*****.**",
Password = "******",
};
//var result = usersService.GetAll();
//Assert.IsNotNull(result);
usersService.Create(added);
usersService.Create(added2);
int number = usersService.GetAll().Count();
Assert.IsNotNull(number);
Assert.AreEqual(2, number);
}
}
public void GetAllShouldReturnCorrectNumberOfPagesForExpenses()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPagesForExpenses))
.Options;
using (var context = new ExpensesDbContext(options))
{
var expenseService = new ExpenseService(context);
var added = expenseService.Create(new LabII.DTOs.ExpensePostModel
{
Description = "Variable",
Type = "5",
Location = "Sibiu",
Date = Convert.ToDateTime("2019-05-05T11:11:11"),
Currency = "USD",
Sum = 555.77,
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "Very important expense",
Owner = null
}
},
}, null);
DateTime from = DateTime.Parse("2019-04-13T00:00:00");
DateTime to = DateTime.Parse("2019-06-19T00:00:00");
var allExpenses = expenseService.GetAll(1, from, to);
Assert.AreEqual(1, allExpenses.Entries.Count);
Assert.IsNotNull(allExpenses);
}
}
public void ValidUpsert1()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidUpsert1))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
UserRoleService userRoleService = new UserRoleService(context);
var added = new Lab2Expense.ViewModels.UserRolePostModel
{
Name = "Regular",
Description = "jskds"
};
var addedForUpdate = new Lab2Expense.ViewModels.UserRolePostModel
{
Name = "Admin",
Description = "smands"
};
var addedForUpdate2 = new Lab2Expense.Models.UserRole
{
Name = "UserManager",
Description = "smands"
};
var result = userRoleService.Create(added);
context.Entry(result).State = EntityState.Detached;
added.Name = "Admin";
var resultUpsert = userRoleService.Upsert(result.Id, added);
var resultNull = userRoleService.Upsert(8, added);
Assert.AreEqual("Admin", resultNull.Name);
Assert.AreEqual("Admin", resultUpsert.Name);
}
}
public void GetAll()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateANewExpense))// "CreateANewTask")
.Options;
using (var context = new ExpensesDbContext(options))
{
var expenseService = new ExpenseService(context);
User user = new User
{
Username = "******"
};
PostExpenseDto expense = new PostExpenseDto
{
Description = "tdssgafgadfla"
};
PostExpenseDto expense2 = new PostExpenseDto
{
Description = "Alallalalalaal"
};
PostExpenseDto expense3 = new PostExpenseDto
{
Description = "fdsjgaoidsfhgasidl"
};
expenseService.Create(expense, user);
expenseService.Create(expense2, user);
expenseService.Create(expense3, user);
var populated = expenseService.GetAll(1);
var empty = expenseService.GetAll(2);
Assert.AreEqual(4, populated.Entries.Count);
Assert.Zero(empty.Entries.Count);
}
}
public void ValidGetCurentRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetCurentRole))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, config);
var added = new Lab2Expense.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******"
};
var userRoleService = new UserRoleService(context);
var addedRole = new Lab2Expense.ViewModels.UserRolePostModel
{
Name = "Regular",
Description = "jskds"
};
var result = userRoleService.Create(addedRole);
var resultAdded = usersService.Register(added);
var resultAuthentificate = usersService.Authenticate(added.Username, added.Password);
var user = context.Users.FirstOrDefault(u => u.Id == resultAuthentificate.Id);
var userRole = usersService.GetCurrentUserRole(user);
Assert.AreEqual("Regular", userRole.Name);
}
}
public void ValidRegisterShouldCreateANewUser()
{
var options = new DbContextOptionsBuilder <LabII.Models.ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateANewUser))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UsersService(context, config);
var added = new LabII.DTOs.RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "Petre",
LastName = "Popescu",
Password = "******",
Username = "******",
};
var result = usersService.Register(added);
Assert.IsNotNull(result);
Assert.AreEqual(added.Username, result.Username);
}
}
public void ValidGetAllShouldReturnAllRegisteredUsers()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetAllShouldReturnAllRegisteredUsers))
.Options;
using (var context = new ExpensesDbContext(options))
{
var regValidator = new RegisterValidator();
var crValidator = new CreateValidator();
var usersService = new UsersService(context, regValidator, crValidator, null, config);
var added1 = new Lab6.Viewmodels.RegisterPostModel
{
FirstName = "Catalin",
LastName = "Albulescu",
Username = "******",
Email = "*****@*****.**",
Password = "******",
};
var added2 = new Lab6.Viewmodels.RegisterPostModel
{
FirstName = "testfname",
LastName = "testsname",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
usersService.Register(added1);
usersService.Register(added2);
int numberOfElements = usersService.GetAll().Count();
Assert.NotZero(numberOfElements);
Assert.AreEqual(2, numberOfElements);
}
}
public void GetAllShouldReturnCorrectNumberOfPagesForComments()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPagesForComments))
.Options;
using (var context = new ExpensesDbContext(options))
{
var taskService = new ExpenseService(context);
var commentService = new CommentService(context);
var added = new ExpensePostModel()
{
Description = "Variable",
Type = "5",
Location = "Sibiu",
Date = Convert.ToDateTime("2019-05-05T11:11:11"),
Currency = "USD",
Sum = 555.77,
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "An important expense",
Owner = null
}
},
};
var current = taskService.Create(added, null);
var allComments = commentService.GetAll(string.Empty, 1);
Assert.AreEqual(1, allComments.NumberOfPages);
}
}
public void CreateShouldAddAndReturnTheCreatedComment()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldAddAndReturnTheCreatedComment))
.Options;
using (var context = new ExpensesDbContext(options))
{
var commentsService = new CommentService(context);
var toAdd = new CommentPostModel()
{
Important = true,
Text = "An important expense",
};
var added = commentsService.Create(toAdd, null);
Assert.IsNotNull(added);
Assert.AreEqual("An important expense", added.Text);
Assert.True(added.Important);
}
}
public CurrenciesController(ExpensesDbContext context)
{
_context = context;
}
public UsersService(ExpensesDbContext context, IOptions <AppSettings> appSettings)
{
this.context = context;
this.appSettings = appSettings.Value;
}
public StandingOrderProceedRequestHandler(ExpensesDbContext context)
{
this.context = context ?? throw new ArgumentNullException(nameof(context));
}
public ExpenseService(ExpensesDbContext context)
{
this.context = context;
}