protected virtual async Task <TReadModel> CreateModel(TCreateModel createModel, CancellationToken cancellationToken = default(CancellationToken))
{
var identityName = User?.Identity?.Name;
createModel.Created = DateTimeOffset.UtcNow;
createModel.CreatedBy = identityName;
createModel.Updated = DateTimeOffset.UtcNow;
createModel.UpdatedBy = identityName;
// validate model
await CreateValidator.ValidateAndThrowAsync(createModel, cancellationToken : cancellationToken);
// create new entity from model
var entity = Mapper.Map <TEntity>(createModel);
// add to data set, id should be generated
await DataContext
.Set <TEntity>()
.AddAsync(entity, cancellationToken);
// save to database
await DataContext
.SaveChangesAsync(cancellationToken);
// convert to read model
var readModel = await ReadModel(entity.Id, cancellationToken);
return(readModel);
}
public void InvalidRegisterShouldReturnErrorsCollection()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(InvalidRegisterShouldReturnErrorsCollection))
.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.RegisterPostModel
{
FirstName = "firstName1",
LastName = "lastName1",
Username = "******",
Email = "*****@*****.**",
Password = "******" //invalid password should invalidate register
};
var result = usersService.Register(added);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ErrorMessages.Count());
}
}
private readonly CreateValidator _createValidator; // post validator
public PostsController(ApplicationContext context, IMappedPost mappedPost, IMappedCategory mappedCategory, CreateValidator createValidtor)
{
this._mappedCategory = mappedCategory;
this._mappedPost = mappedPost;
this._createValidator = createValidtor;
_context = context;
}
public void CreateShouldReturnNullIfValidUserGetModel()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldReturnNullIfValidUserGetModel))
.Options;
using (var context = new ExpensesDbContext(options))
{
var regValidator = new RegisterValidator();
var crValidator = new CreateValidator();
var usersService = new UsersService(context, regValidator, crValidator, null, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Created for test"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added1 = new Lab6.Viewmodels.UserPostModel
{
FirstName = "firstName",
LastName = "lastName",
UserName = "******",
Email = "*****@*****.**",
Password = "******",
UserRole = "Regular",
};
var userCreated = usersService.Create(added1);
Assert.IsNull(userCreated);
}
}
public void ValidDeleteShouldRemoveTheUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidDeleteShouldRemoveTheUser))
.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.RegisterPostModel
{
FirstName = "firstName1",
LastName = "firstName1",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var userCreated = usersService.Register(added);
Assert.NotNull(userCreated);
//Assert.AreEqual(0, usersService.GetAll().Count());
var userDeleted = usersService.Delete(1);
Assert.Null(userDeleted);
Assert.AreEqual(0, usersService.GetAll().Count());
}
}
public void ValidRegistrationShouldCreateANewUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegistrationShouldCreateANewUser))
.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 added = new RegisterPostModel
{
FirstName = "Catalin",
LastName = "Albulescu",
Username = "******",
Email = "*****@*****.**",
Password = "******",
};
var result = usersService.Register(added);
Assert.IsNull(result);
Assert.AreEqual(added.Username, context.Users.FirstOrDefault(u => u.Id == 1).Username);
//Assert.AreEqual(1, context.UserUserRoles.FirstOrDefault(uur => uur.Id == 1).UserId);
}
}
public async Task <CreateResponse> Create(Create data)
{
var validator = new CreateValidator();
var validResult = validator.Validate(data);
if (validResult.IsValid)
{
var url = _routes[_create];
var sender = new Sender <Create, CreateResponse>();
var result = await sender.Post(data, url);
if (result != null)
{
//if (result.Err != null)
//{
// LogResultError(url, result.Err);
//}
}
else
{
// Logger.Error("Could't recive data. Check internet connection.");
}
return(result);
}
else
{
var errors = validResult.Errors;
LogErrors(errors);
}
return(null);
}
public void GetByIdShouldReturnAnValidUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnAnValidUser))
.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 = "firstName",
LastName = "lastName",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
usersService.Register(added1);
var userById = usersService.GetById(1);
Assert.NotNull(userById);
Assert.AreEqual("firstName", userById.FirstName);
}
}
public void Validate_ValidQuery_ShouldReturnTrue(string query)
{
var validator = new CreateValidator(new Database());
var actual = validator.Validate(query);
Assert.True(actual);
}
public virtual async Task <TOutDto> CreateAsync(TCreateDto inDto)
{
await CreateValidator.ValidateAndThrowAsync(inDto)
.ConfigureAwait(false);
var entity = Mapper.Map <TEntity>(inDto);
await Repository.SaveAsync(entity).ConfigureAwait(false);
return(Mapper.Map <TOutDto>(entity));
}
public CategoriesController(
ICategoryRepository categoryRepository,
IMappedCategory mappedCategory,
CreateValidator createValidator,
EditValidator editValidator
)
{
this._mappedCategory = mappedCategory;
this._categoryRepository = categoryRepository;
this._createValidator = createValidator;
this._editValidator = editValidator;
}
public void AuthenticateShouldLoginTheRegisteredUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLoginTheRegisteredUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new RegisterValidator();
var validatorUser = new UserRoleValidator();
var crValidator = new CreateValidator();
var userUserRoleService = new UserUserRoleService(validatorUser, context);
var usersService = new UsersService(context, validator, crValidator, userUserRoleService, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Created for test"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added = new Lab6.Viewmodels.RegisterPostModel
{
FirstName = "Catalin",
LastName = "Albulescu",
Username = "******",
Email = "*****@*****.**",
Password = "******",
};
var result = usersService.Register(added);
var authenticated = new Lab6.Viewmodels.LoginPostModel
{
Username = "******",
Password = "******"
};
//valid authentification
var authresult = usersService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(authresult);
Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.Username);
//invalid user authentification
//var authresult1 = usersService.Authenticate("unknown", "abcdefg");
//Assert.IsNull(authresult1);
}
}
public override async Task <AuditOutDto> CreateAsync(
CreateAuditDto inDto
)
{
await CreateValidator.ValidateAndThrowAsync(inDto);
var audit = Mapper.Map <Audit>(inDto);
audit.User = await userDbRepository.GetByIdAsync(
id : inDto.UserId.Value
);
await Repository.SaveAsync(audit);
return(Mapper.Map <AuditOutDto>(audit));
}
public void GetCurentUserShouldReturnAccesToKlaims()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetCurentUserShouldReturnAccesToKlaims))
.Options;
using (var context = new ExpensesDbContext(options))
{
var regValidator = new RegisterValidator();
var crValidator = new CreateValidator();
var validatorUser = new UserRoleValidator();
var userUserRoleService = new UserUserRoleService(validatorUser, context);
var usersService = new UsersService(context, regValidator, crValidator, userUserRoleService, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Created for test"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added = new Lab6.Viewmodels.RegisterPostModel
{
FirstName = "firstName",
LastName = "lastName",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new Lab6.Viewmodels.LoginPostModel
{
Username = "******",
Password = "******"
};
var authresult = usersService.Authenticate(added.Username, added.Password);
//usersService.GetCurentUser(httpContext);
Assert.IsNotNull(authresult);
}
}
public CreateTest()
{
_create = new Create()
{
BeerName = "Test",
UserName = "******",
Description = "Test",
Ibu = "145",
Location = "Test",
Style = "T",
BeerId = "1",
BreweryName = "T",
BreweryState = "OR",
LabelPath = "Test",
UntappedId = "1",
AlcoholByVolume = "5"
};
_validator = new CreateValidator();
}
public void UpsertShouldModifyFildsValues()
{
var options = new DbContextOptionsBuilder <TasksDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldModifyFildsValues))
.Options;
using (var context = new TasksDbContext(options))
{
var validator = new RegisterValidator();
var validator1 = new CreateValidator();
var validatorUser = new UserRoleValidator();
var userUserRoleService = new UserUserRolesService(validatorUser, context);
var usersService = new UsersService(context, validator, validator1, userUserRoleService, config);
var added = new UserPostDTO()
{
FirstName = "Julia",
LastName = "Bush",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var IsIn = usersService.Create(added);
var added1 = new UserPostDTO()
{
FirstName = "Maya",
LastName = "Bush",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
Assert.IsNull(IsIn);
Assert.AreNotEqual(added.FirstName, added1.FirstName);
}
}
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 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 Validate_InvalidQuery_ShouldThrowAnException(string query)
{
var validator = new CreateValidator(new Database());
Assert.ThrowsAny <Exception>(() => validator.Validate(query));
}
