public UserRequestHintCommandHandlerTests()
{
_entityTables = new InMemoryEntityTables();
_emailService = new Mock <IEmailService>();
_userRequestHintCommandHandler = new UserRequestHintCommandHandler(_entityTables, _emailService.Object);
_entityTables.Users.Create();
}
public static async Task <AccountHintEntity> GetLatestHint(this IEntityTables entityTables, string userId, string accountId, IEnumerable <string> selectedColumns, Func <AccountHintEntity, AccountHintEntity> selector, CancellationToken cancellationToken)
{
var latestAccountHint = default(AccountHintEntity);
var query = new TableQuery <AccountHintEntity>()
.Where(
TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition(nameof(ITableEntity.PartitionKey), QueryComparisons.Equal, userId.ToEncodedKeyProperty()),
TableOperators.And,
TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition(nameof(ITableEntity.RowKey), QueryComparisons.GreaterThan, $"id-{accountId}-hintId-".ToEncodedKeyProperty()),
TableOperators.And,
TableQuery.GenerateFilterCondition(nameof(HintKeepTableEntity.EntityType), QueryComparisons.Equal, "AccountHintEntity")
)
)
)
.Select(new[] { nameof(AccountHintEntity.Hint), nameof(AccountHintEntity.DateAdded) }.Concat(selectedColumns ?? Array.Empty <string>()).ToArray());
var continuationToken = default(TableContinuationToken);
do
{
var accountHintsSegment = await entityTables.Accounts.ExecuteQuerySegmentedAsync(query, continuationToken, cancellationToken);
continuationToken = accountHintsSegment.ContinuationToken;
foreach (var accountHint in (selector is null ? accountHintsSegment : accountHintsSegment.Select(selector)))
{
if (AccountHintEntitySortOrderComparer.Compare(accountHint, latestAccountHint) < 0)
{
latestAccountHint = accountHint;
}
}
} while (continuationToken is object);
return(latestAccountHint);
}
public RegisterUserCommandHandlerTests()
{
_entityTables = new InMemoryEntityTables();
_emailService = new Mock <IEmailService>();
_securityService = new Mock <ISecurityService>();
_entityTables.Users.Create();
_registerUserCommandHandler = new RegisterUserCommandHandler(_entityTables, _emailService.Object, _securityService.Object);
}
public CreateUserSessionCommandHandlerTests()
{
_entityTables = new InMemoryEntityTables();
_securityService = new Mock <ISecurityService>();
_sessionService = new Mock <ISessionService>();
_createUserSessionCommandHandler = new CreateUserSessionCommandHandler(_entityTables, _securityService.Object, _sessionService.Object);
_entityTables.Users.Create();
}
public UserRequestPasswordResetCommandHandlerTests()
{
_entityTables = new InMemoryEntityTables();
_securityService = new Mock <ISecurityService>();
_emailService = new Mock <IEmailService>();
_userRequestPasswordResetCommand = new UserRequestPasswordResetCommandHandler(_entityTables, _securityService.Object, _emailService.Object);
_entityTables.Users.Create();
}
private static void _EnsureAzureTableStorage(IEntityTables entityTables)
{
var cloudTables = typeof(IEntityTables)
.GetProperties()
.Where(property => property.CanRead && property.PropertyType == typeof(CloudTable))
.Select(property => property.GetValue(entityTables))
.Cast <CloudTable>();
foreach (var cloudTable in cloudTables)
{
cloudTable.CreateIfNotExists();
}
}
public static IEntityTables AddAccounts(this IEntityTables entityTables, IEnumerable <Account> accounts)
{
foreach (var account in accounts)
{
var tableBatchOperation = new TableBatchOperation
{
TableOperation.Insert(new IndexEntity
{
EntityType = "IndexEntity",
PartitionKey = account.UserId.ToEncodedKeyProperty(),
RowKey = $"name-{account.Name.ToLowerInvariant()}".ToEncodedKeyProperty(),
IndexedEntityId = account.Id,
}),
TableOperation.Insert(new AccountEntity
{
EntityType = "AccountEntity",
PartitionKey = account.UserId.ToEncodedKeyProperty(),
RowKey = $"id-{account.Id}".ToEncodedKeyProperty(),
Id = account.Id,
Name = account.Name,
Hint = account.Hints.OrderByDescending(accountHint => accountHint.DateAdded).Select(accountHint => accountHint.Hint).FirstOrDefault(),
Notes = account.Notes,
IsPinned = account.IsPinned,
IsDeleted = account.IsDeleted
})
};
foreach (var accountHint in account.Hints)
{
tableBatchOperation.Add(TableOperation.Insert(new AccountHintEntity
{
EntityType = "AccountHintEntity",
PartitionKey = account.UserId.ToEncodedKeyProperty(),
RowKey = $"id-{account.Id}-hintId-{accountHint.Id}".ToEncodedKeyProperty(),
AccountId = account.Id,
HintId = accountHint.Id,
Hint = accountHint.Hint,
DateAdded = accountHint.DateAdded
}));
}
entityTables.Accounts.ExecuteBatch(tableBatchOperation);
}
return(entityTables);
}
public DeleteAccountCommandHandlerTests()
{
_entityTables = new InMemoryEntityTables();
_entityTables.Accounts.Create();
_moveAccountToBinCommandHandler = new DeleteAccountCommandHandler(_entityTables, new Session("#user-id"));
}
public GetAccountDetailsQueryHandler(IEntityTables entityTables, Session login) => (_entityTables, _login) = (entityTables, login);
public MoveAccountToBinCommandHandler(IEntityTables entityTables, Session login) => (_entityTables, _login) = (entityTables, login);
public UpdateAccountCommandHandler(IEntityTables entityTables, Session login) => (_entityTables, _login) = (entityTables, login);
public AddAccountHintCommandHandler(IEntityTables entityTables, Session session) => (_entityTables, _session) = (entityTables, session);
public UpdateAccountCommandHandlerTests()
{
_entityTables = new InMemoryEntityTables();
_entityTables.Accounts.Create();
_updateAccountCommandHandler = new UpdateAccountCommandHandler(_entityTables, new Session("#user-id"));
}
public ConfirmUserCommandHandlerTests()
{
_entityTables = new InMemoryEntityTables();
_confirmUserCommandHandler = new ConfirmUserCommandHandler(_entityTables);
_entityTables.Users.Create();
}
public GetDeletedAccountsQueryHandler(IEntityTables entityTables, Session login) => (_entityTables, _login) = (entityTables, login);
public static Task <AccountHintEntity> GetLatestHint(this IEntityTables entityTables, string userId, string accountId, IEnumerable <string> selectedColumns, CancellationToken cancellationToken) => entityTables.GetLatestHint(userId, accountId, selectedColumns, null, cancellationToken);
public AccountHintsQueryHandler(IEntityTables entityTables, Session session) => (_entityTables, _session) = (entityTables, session);
public ConfirmUserCommandHandler(IEntityTables entityTables) => _entityTables = entityTables;
public CreateUserSessionCommandHandler(IEntityTables entityTables, ISecurityService securityService, ISessionService sessionService) => (_entityTables, _securityService, _sessionService) = (entityTables, securityService, sessionService);
public UserRequestHintCommandHandler(IEntityTables entityTables, IEmailService emailService) => (_entityTables, _emailService) = (entityTables, emailService);
public RegisterUserCommandHandler(IEntityTables entityTables, IEmailService emailService, ISecurityService securityService) => (_entityTables, _emailService, _securityService) = (entityTables, emailService, securityService);
public static IEntityTables AssertAccounts(this IEntityTables entityTables, params Account[] accounts) => entityTables.AssertAccounts((IEnumerable <Account>)accounts);
public static IEntityTables AssertAccounts(this IEntityTables entityTables, IEnumerable <Account> accounts)
{
foreach (var account in accounts)
{
Assert.NotNull(account.UserId);
}
Assert.Equal(accounts.Sum(account => 2 + account.Hints.Count), entityTables.Accounts.ExecuteQuery(new TableQuery()).Count());
foreach (var account in accounts)
{
var indexEntity = (IndexEntity)entityTables.Accounts.Execute(TableOperation.Retrieve <IndexEntity>(account.UserId.ToEncodedKeyProperty(), $"name-{account.Name.ToLowerInvariant()}".ToEncodedKeyProperty())).Result;
Assert.NotNull(indexEntity);
Assert.Equal("IndexEntity", indexEntity.EntityType);
Assert.Equal(account.UserId, indexEntity.PartitionKey.FromEncodedKeyProperty());
Assert.Equal($"name-{account.Name.ToLowerInvariant()}", indexEntity.RowKey.FromEncodedKeyProperty());
Assert.Equal(account.Id, indexEntity.IndexedEntityId);
var accountEntity = (AccountEntity)entityTables.Accounts.Execute(TableOperation.Retrieve <AccountEntity>(account.UserId.ToEncodedKeyProperty(), $"id-{account.Id}".ToEncodedKeyProperty())).Result;
Assert.NotNull(accountEntity);
Assert.Equal("AccountEntity", accountEntity.EntityType);
Assert.Equal(account.UserId, accountEntity.PartitionKey.FromEncodedKeyProperty());
Assert.Equal($"id-{account.Id}", accountEntity.RowKey.FromEncodedKeyProperty());
Assert.Equal(account.Id, accountEntity.Id);
Assert.Equal(account.Name, accountEntity.Name);
Assert.Equal(account.Hints.Select(accountHint => accountHint.Hint).FirstOrDefault() ?? string.Empty, accountEntity.Hint);
Assert.Equal(account.Notes, accountEntity.Notes);
if (account.IsPinned)
{
Assert.True(accountEntity.IsPinned);
}
else
{
Assert.False(accountEntity.IsPinned);
}
if (account.IsDeleted)
{
Assert.True(accountEntity.IsDeleted);
}
else
{
Assert.False(accountEntity.IsDeleted);
}
foreach (var accountHint in account.Hints)
{
var accountHintEntity = (AccountHintEntity)entityTables.Accounts.Execute(TableOperation.Retrieve <AccountHintEntity>(account.UserId.ToEncodedKeyProperty(), $"id-{account.Id}-hintId-{accountHint.Id}".ToEncodedKeyProperty())).Result;
Assert.NotNull(accountHintEntity);
Assert.Equal("AccountHintEntity", accountHintEntity.EntityType);
Assert.Equal(account.UserId, accountHintEntity.PartitionKey.FromEncodedKeyProperty());
Assert.Equal($"id-{account.Id}-hintId-{accountHint.Id}", accountHintEntity.RowKey.FromEncodedKeyProperty());
Assert.Equal(account.Id, accountHintEntity.AccountId);
Assert.Equal(accountHint.Id, accountHintEntity.HintId);
Assert.Equal(accountHint.Hint, accountHintEntity.Hint);
Assert.Equal(accountHint.DateAdded, accountHintEntity.DateAdded);
}
}
return(entityTables);
}
public UserPasswordResetCommandHandler(IEntityTables entityTables, ISecurityService securityService, IEmailService emailService) => (_entityTables, _securityService, _emailService) = (entityTables, securityService, emailService);
public AccountHintsQueryHandlerTests()
{
_entityTables = new InMemoryEntityTables();
_entityTables.Accounts.Create();
_accountHintsQueryHandler = new AccountHintsQueryHandler(_entityTables, new Session("#user-id"));
}
public GetDeletedAccountDetailsQueryHandlerTests()
{
_entityTables = new InMemoryEntityTables();
_entityTables.Accounts.Create();
_getAccountsQueryHandler = new GetDeletedAccountDetailsQueryHandler(_entityTables, new Session("#user-id"));
}
public static Task <AccountHintEntity> GetLatestHint(this IEntityTables entityTables, string userId, string accountId, CancellationToken cancellationToken) => entityTables.GetLatestHint(userId, accountId, Array.Empty <string>(), null, cancellationToken);
