public async Task GetAccounts_WithoutAccess_ShouldFail()
{
Bogus.Faker faker = new Bogus.Faker();
var identity = faker.Random.Identity();
var accountUserFaker = new Common.Fakers.AccountUserFaker();
var master = accountUserFaker.Generate();
var newAccountUserFaker = accountUserFaker
.RuleFor(au => au.UserId, master.UserId)
.RuleFor(au => au.UserDescription, master.AccountDescription);
var originalAccountUserList = newAccountUserFaker.Generate(3);
var mockAuthorizationService = new Mock <IAuthorizationService>();
mockAuthorizationService.Setup(a => a.CheckAuthorizedUser(identity, master.UserId, AccessType.Read)).ReturnsAsync(false);
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(ur => ur.GetAccounts(master.UserId)).ReturnsAsync(originalAccountUserList);
var userQueryHandler = new UserQueryHandler(mockAuthorizationService.Object, mockUserRepository.Object);
await Assert.ThrowsAsync <UnauthorizedAccessException>(async() => await userQueryHandler.GetAccounts(identity, master.UserId));
mockUserRepository.VerifyNoOtherCalls();
}
public HomeController(Course.DisciplineQueryHandler disciplineQuery, EnrollmentQueryHandler enrollmentQuery, Evaluation.DisciplineQueryHandler disciplineEvaluationQuery,
UserQueryHandler userQuery) : base(userQuery)
{
_disciplineQuery = disciplineQuery;
_enrollmentQuery = enrollmentQuery;
_disciplineEvaluationQuery = disciplineEvaluationQuery;
}
public async Task Should_Get_User_Profile_When_User_Found()
{
//Arrange
var applicationUser = new ApplicationUser
{
Email = String.Empty,
UserName = String.Empty,
FirstName = "Test",
LastName = "Test",
Id = 1,
PasswordHash = String.Empty
};
var message = new UserQuery(applicationUser.Id);
Mock <IUserManagerService> userManagerService = new Mock <IUserManagerService>();
userManagerService.Setup(s => s.GetUserById(It.IsAny <int>())).ReturnsAsync(applicationUser);
var sut = new UserQueryHandler(userManagerService.Object, _mapper);
//ActT
var result = await sut.Handle(message, default);
//Assert
result.ShouldNotBeNull();
result.ShouldBeOfType <UserDetailInfoDto>();
result.Id.ShouldBe(applicationUser.Id);
result.FirstName.ShouldBe(applicationUser.FirstName);
result.LastName.ShouldBe(applicationUser.LastName);
}
public async Task GetIdentities_ShouldSucceed()
{
Bogus.Faker faker = new Bogus.Faker();
var identity = faker.Random.Identity();
var userIdentityFaker = new Common.Fakers.UserIdentityFaker();
var master = userIdentityFaker.Generate();
var newUserIdentityFaker = userIdentityFaker
.RuleFor(au => au.UserId, master.UserId);
var originalUserIdentityList = newUserIdentityFaker.Generate(3);
var mockAuthorizationService = new Mock <IAuthorizationService>();
mockAuthorizationService.Setup(a => a.CheckAuthorizedUser(identity, master.UserId, AccessType.Read)).ReturnsAsync(true);
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(ur => ur.GetIdentities(master.UserId)).ReturnsAsync(originalUserIdentityList);
var userQueryHandler = new UserQueryHandler(mockAuthorizationService.Object, mockUserRepository.Object);
var userIdentitiesList = await userQueryHandler.GetIdentities(identity, master.UserId);
originalUserIdentityList.ShouldDeepEqual(userIdentitiesList);
mockAuthorizationService.Verify(a => a.CheckAuthorizedUser(identity, master.UserId, AccessType.Read));
mockAuthorizationService.VerifyNoOtherCalls();
mockUserRepository.Verify(ur => ur.GetIdentities(master.UserId));
mockUserRepository.VerifyNoOtherCalls();
}
public DisciplineController(DisciplineCommandHandler disciplineCommand, DisciplineQueryHandler disciplineQuery, CourseQueryHandler courseQuery,
ProfessorQueryHandler professorQuery, UserQueryHandler userQuery) : base(userQuery)
{
_disciplineCommand = disciplineCommand;
_disciplineQuery = disciplineQuery;
_courseQuery = courseQuery;
_professorQuery = professorQuery;
}
public UserController(
UserCommandHandler commandHandler,
UserQueryHandler queryHandler,
IMapper mapper)
{
_commandHandler = commandHandler;
_queryHandler = queryHandler;
_mapper = mapper;
}
public async Task UserDoesNotExist()
{
var query = new UserQuery {
UserId = string.Empty
};
var handler = new UserQueryHandler(Context);
var result = await handler.Handle(query);
Assert.Null(result);
}
public async Task UserExists()
{
var query = new UserQuery()
{
UserId = _userId
};
var handler = new UserQueryHandler(Context);
var result = await handler.Handle(query);
Assert.NotNull(result);
}
public async Task Should_Throw_NotFoundException_In_Get_User_Profile_When_User_Not_Found()
{
//Arrange
var applicationUser = new ApplicationUser
{
Email = String.Empty,
UserName = String.Empty,
FirstName = "Test",
LastName = "Test",
Id = 1,
PasswordHash = String.Empty
};
var message = new UserQuery(applicationUser.Id);
Mock <IUserManagerService> userManagerService = new Mock <IUserManagerService>();
userManagerService.Setup(s => s.GetUserById(It.IsAny <int>())).Throws <NotFoundException>();
var sut = new UserQueryHandler(userManagerService.Object, _mapper);
//Act/Assert
await Assert.ThrowsAsync <NotFoundException>(async() => { await sut.Handle(message, default); });
}
static void Main(string[] args)
{
//Setup code...
Console.WriteLine("Connecting to EventStore...");
EventStoreLoader.SetupEventStore(EventStoreLoader.StartConflictOption.Connect);
//create instance of the user service
userService = new UserService(new EsAggregateStore(EventStoreLoader.Connection));
//read models and projections
var items = new List <UserReadModel>();
projectionManager = new ProjectionManager(EventStoreLoader.Connection, items);
//command and query handlers
userCommands = new UserCommandHandler(userService);
userQueries = new UserQueryHandler(items, userService); //need list of read model items
Console.WriteLine("EventStore was setup successfully!");
DisplayUserCommands();
StartCommandLoop();
}
public StudentController(StudentQueryHandler studentQuery, StudentCommandHandler studentCommand, CourseQueryHandler courseQuery, UserQueryHandler userQuery) : base(userQuery)
{
_studentQuery = studentQuery;
_studentCommand = studentCommand;
_courseQuery = courseQuery;
}
public ControllerBase(UserQueryHandler userQuery)
{
_userQuery = userQuery;
}
public GradeController(Evaluation.DisciplineQueryHandler disciplineQuery, EnrollmentQueryHandler enrollmentQuery, ActivityQueryHandler activityQuery, UserQueryHandler userQuery) : base(userQuery)
{
_disciplineQuery = disciplineQuery;
_enrollmentQuery = enrollmentQuery;
_activityQuery = activityQuery;
}
public IEnumerable <User> QueryUsers(UserListQuery command)
{
var handler = new UserQueryHandler();
return(handler.Handle(command));
}
public User QueryUserDetails(UserDetailsQuery command)
{
var handler = new UserQueryHandler();
return(handler.Handle(command));
}
public ProfessorController(ProfessorQueryHandler professorQuery, ProfessorCommandHandler professorCommand, UserQueryHandler userQuery) : base(userQuery)
{
_professorQuery = professorQuery;
_professorCommand = professorCommand;
}
public UsersController(UserQueryHandler query, UserCommandHandler command)
{
_query = query;
_command = command;
}
public AccountController(UserQueryHandler userQuery) : base(userQuery)
{
_userQuery = userQuery;
}
public ExamController(ActivityQueryHandler activityQuery, StudentQueryHandler studentQuery, ActivityCommandHandler activityCommand, Evaluation.Queries.ActivityQueryHandler activityEvaluationQuery,
Evaluation.Handlers.ActivityCommandHandler activityEvaluationCommand, UserQueryHandler userQuery) : base(userQuery)
{
_activityQuery = activityQuery;
_activityCommand = activityCommand;
_studentQuery = studentQuery;
_activityEvaluationQuery = activityEvaluationQuery;
_activityEvaluationCommand = activityEvaluationCommand;
}
public UserQueryHandlerTests()
{
UserRepository = new Mock <IUserRepository>();
UserQueryHandler = new UserQueryHandler(UserRepository.Object);
}
public ActivityController(ActivityCommandHandler activityCommand, ActivityQueryHandler activityQuery, DisciplineQueryHandler disciplineQuery,
StudentQueryHandler studentQuery, UseCases.EvaluationContext.Queries.ActivityQueryHandler activityEvaluationQuery,
UseCases.EvaluationContext.Handlers.ActivityCommandHandler activityEvaluationCommad, UserQueryHandler userQuery) : base(userQuery)
{
_activityCommand = activityCommand;
_activityQuery = activityQuery;
_disciplineQuery = disciplineQuery;
_studentQuery = studentQuery;
_activityEvaluationQuery = activityEvaluationQuery;
_activityEvaluationCommad = activityEvaluationCommad;
}
public LoginService(UserQueryHandler query, ITokenService token)
{
_query = query;
_token = token;
}
public EnrollmentController(EnrollmentQueryHandler enrollmentQuery, EnrollmentCommandHandler enrollmentCommand, CourseQueryHandler courseQuery,
StudentQueryHandler studentQuery, EnrollmentDisciplineQueryHandler disciplineQuery, UserQueryHandler userQuery) : base(userQuery)
{
_enrollmentQuery = enrollmentQuery;
_enrollmentCommand = enrollmentCommand;
_courseQuery = courseQuery;
_studentQuery = studentQuery;
_disciplineQuery = disciplineQuery;
}
