Exemplo n.º 1
0
        public Task AssignCashierToAccountAccountShouldReturnProperHypermediaLinks(HireCashier hireCommand, Register registerCommand) =>
        _apiHelper.InTheContextOfAnAdmin(
            async httpClient =>
        {
            // Arrange
            await _fixture.SendManyAsync(hireCommand, registerCommand);

            var assignCommand = new AssignCashierToAccount
            {
                AccountId = registerCommand.Id,
                CashierId = hireCommand.Id
            };

            // Act
            var response = await httpClient
                           .PostAsJsonAsync(AuthRoute("assign/cashier"), assignCommand);

            // Assert
            var expectedLinks = new List <string>
            {
                LinkNames.Self,
                LinkNames.Auth.AssignWaiter,
                LinkNames.Auth.AssignManager,
                LinkNames.Auth.AssignBarista
            };

            await response.ShouldBeAResource <AssignCashierToAccountResource>(expectedLinks);
        });
Exemplo n.º 2
0
        public async Task CanAssignCashierToAccount(Register accountToRegisterCommand, Cashier cashierToAssign)
        {
            // Arrange
            await _fixture.ExecuteDbContextAsync(async dbContext =>
            {
                dbContext.Cashiers.Add(cashierToAssign);
                await dbContext.SaveChangesAsync();
            });

            await _fixture.SendAsync(accountToRegisterCommand);

            var commandToTest = new AssignCashierToAccount
            {
                CashierId = cashierToAssign.Id,
                AccountId = accountToRegisterCommand.Id
            };

            // Act
            var result = await _fixture.SendAsync(commandToTest);

            // Assert
            await _helper.LoginAndCheckClaim(
                accountToRegisterCommand.Email,
                accountToRegisterCommand.Password,
                c => c.Type == AuthConstants.ClaimTypes.CashierId &&
                c.Value == cashierToAssign.Id.ToString());
        }
Exemplo n.º 3
0
        public async Task CannotAssignUnexistingCashier(Register registerAccountCommand)
        {
            // Arrange
            // Purposefully skipping adding any cashiers
            var commandToTest = new AssignCashierToAccount
            {
                CashierId = Guid.NewGuid(),
                AccountId = registerAccountCommand.Id
            };

            // Act
            var result = await _fixture.SendAsync(commandToTest);

            // Assert
            result.ShouldHaveErrorOfType(ErrorType.NotFound);
        }
Exemplo n.º 4
0
        public async Task AssignedRolesAreCorrectlyReturned(Register userToRegister, HireWaiter waiterToAssign, HireCashier cashierToAssign)
        {
            // Arrange
            await _fixture.SendAsync(userToRegister);

            await _fixture.SendAsync(waiterToAssign);

            await _fixture.SendAsync(cashierToAssign);

            var assignWaiterToAccount = new AssignWaiterToAccount
            {
                WaiterId  = waiterToAssign.Id,
                AccountId = userToRegister.Id
            };

            var assignCashierToAccount = new AssignCashierToAccount
            {
                AccountId = userToRegister.Id,
                CashierId = cashierToAssign.Id
            };

            await _fixture.SendAsync(assignWaiterToAccount);

            await _fixture.SendAsync(assignCashierToAccount);

            // Act
            var result = await _fixture.SendAsync(new GetUser { Id = userToRegister.Id });

            // Assert
            result.Exists(u =>
                          u.Id == userToRegister.Id &&
                          u.WaiterId == waiterToAssign.Id &&
                          u.CashierId == cashierToAssign.Id &&
                          u.IsWaiter &&
                          u.IsCashier &&
                          u.BaristaId == null &&
                          u.ManagerId == null &&
                          !u.IsBarista &&
                          !u.IsManager)
            .ShouldBeTrue();
        }
Exemplo n.º 5
0
        public async Task CannotAssignUnexistingAccount(Cashier cashierToAdd)
        {
            // Arrange
            await _fixture.ExecuteDbContextAsync(async dbContext =>
            {
                dbContext.Cashiers.Add(cashierToAdd);
                await dbContext.SaveChangesAsync();
            });

            var commandToTest = new AssignCashierToAccount
            {
                CashierId = cashierToAdd.Id,
                AccountId = Guid.NewGuid()
            };

            // Act
            var result = await _fixture.SendAsync(commandToTest);

            // Assert
            result.ShouldHaveErrorOfType(ErrorType.NotFound);
        }
Exemplo n.º 6
0
        public async Task CanReassignCashierForAccount(Register registerAccountCommand, Cashier cashierToAssign, Cashier cashierToReassign)
        {
            // Arrange
            await _fixture.ExecuteDbContextAsync(async dbContext =>
            {
                dbContext.Cashiers.Add(cashierToAssign);
                dbContext.Cashiers.Add(cashierToReassign);
                await dbContext.SaveChangesAsync();
            });

            await _fixture.SendAsync(registerAccountCommand);

            var assignFirstCashierCommand = new AssignCashierToAccount
            {
                CashierId = cashierToAssign.Id,
                AccountId = registerAccountCommand.Id
            };

            // Note that first we've assigned a cashier before attempting a second time
            await _fixture.SendAsync(assignFirstCashierCommand);

            var commandToTest = new AssignCashierToAccount
            {
                AccountId = registerAccountCommand.Id,
                CashierId = cashierToReassign.Id
            };

            // Act
            var result = await _fixture.SendAsync(commandToTest);

            // Assert
            await _helper.LoginAndCheckClaim(
                registerAccountCommand.Email,
                registerAccountCommand.Password,
                c => c.Type == AuthConstants.ClaimTypes.CashierId &&
                c.Value == cashierToReassign.Id.ToString());
        }
Exemplo n.º 7
0
 public async Task <IActionResult> AssignCashierToAccount([FromBody] AssignCashierToAccount command) =>
 (await Mediator.Send(command)
  .MapAsync(ToEmptyResourceAsync <AssignCashierToAccountResource>))
 .Match(Ok, Error);