public void BuildsExpectedIndexForCodeGeneratedEventDto()
{
var searchIndex = new EventSearchIndexDefinition <DepositedEventDTO>();
var depositedEventDto = new DepositedEventDTO
{
NewBalance = new HexBigInteger("100"),
Value = new HexBigInteger("10"),
Sender = "adsfadsfasdfasdf"
};
Assert.Equal("Deposited", searchIndex.IndexName);
Assert.Equal(12, searchIndex.Fields.Length);
var senderField = searchIndex.Field(nameof(depositedEventDto.Sender));
Assert.NotNull(senderField);
Assert.Equal(typeof(string), senderField.DataType);
Assert.False(senderField.IsKey);
Assert.False(senderField.Ignore);
Assert.True(senderField.IsFacetable);
Assert.True(senderField.IsFilterable);
Assert.True(senderField.IsSearchable);
Assert.True(senderField.IsSortable);
Assert.Equal(depositedEventDto.Sender, senderField.EventValue(depositedEventDto));
var valueField = searchIndex.Field(nameof(depositedEventDto.Value));
Assert.NotNull(valueField);
Assert.Equal(typeof(BigInteger), valueField.DataType);
Assert.False(valueField.IsKey);
Assert.False(valueField.Ignore);
Assert.False(valueField.IsSearchable);
Assert.False(valueField.IsFilterable);
Assert.False(valueField.IsFacetable);
Assert.False(valueField.IsSortable);
Assert.Equal(depositedEventDto.Value, valueField.EventValue(depositedEventDto));
var newBalanceField = searchIndex.Field(nameof(depositedEventDto.NewBalance));
Assert.NotNull(newBalanceField);
Assert.Equal(typeof(BigInteger), newBalanceField.DataType);
Assert.False(newBalanceField.IsKey);
Assert.False(newBalanceField.Ignore);
Assert.False(newBalanceField.IsSearchable);
Assert.False(newBalanceField.IsFilterable);
Assert.False(newBalanceField.IsFacetable);
Assert.False(newBalanceField.IsSortable);
Assert.Equal(depositedEventDto.NewBalance, newBalanceField.EventValue(depositedEventDto));
var log_key = searchIndex.Field(PresetSearchFieldName.log_key);
var log_removed = searchIndex.Field(PresetSearchFieldName.log_removed);
var log_type = searchIndex.Field(PresetSearchFieldName.log_type);
var log_logIndex = searchIndex.Field(PresetSearchFieldName.log_log_index);
var log_transactionIndex = searchIndex.Field(PresetSearchFieldName.log_transaction_index);
var log_transactionHash = searchIndex.Field(PresetSearchFieldName.log_transaction_hash);
var log_blockHash = searchIndex.Field(PresetSearchFieldName.log_block_hash);
var log_blockNumber = searchIndex.Field(PresetSearchFieldName.log_block_number);
var log_address = searchIndex.Field(PresetSearchFieldName.log_address);
var filterLog = new FilterLog
{
Type = "type",
Address = "address",
BlockHash = "block_hash",
BlockNumber = new HexBigInteger(101),
TransactionHash = "transaction_hash",
TransactionIndex = new HexBigInteger(3),
LogIndex = new HexBigInteger(9),
Removed = false
};
Assert.NotNull(log_key);
Assert.Equal(typeof(string), log_key.DataType);
Assert.True(log_key.IsKey);
Assert.True(log_key.IsSortable);
Assert.False(log_key.Ignore);
Assert.False(log_key.IsSearchable);
Assert.False(log_key.IsFacetable);
Assert.False(log_key.IsFilterable);
Assert.Equal("101_3_9", log_key.LogValueCallback(filterLog));
Assert.NotNull(log_removed);
Assert.Equal(typeof(bool), log_removed.DataType);
Assert.False(log_removed.Ignore);
Assert.False(log_removed.IsKey);
Assert.False(log_removed.IsFacetable);
Assert.True(log_removed.IsFilterable);
Assert.False(log_removed.IsSearchable);
Assert.True(log_removed.IsSortable);
Assert.Equal(filterLog.Removed, log_removed.LogValueCallback(filterLog));
Assert.NotNull(log_type);
Assert.Equal(typeof(string), log_type.DataType);
Assert.False(log_type.Ignore);
Assert.False(log_type.IsKey);
Assert.False(log_type.IsFacetable);
Assert.True(log_type.IsFilterable);
Assert.False(log_type.IsSearchable);
Assert.True(log_type.IsSortable);
Assert.Equal(filterLog.Type, log_type.LogValueCallback(filterLog));
Assert.NotNull(log_logIndex);
Assert.Equal(typeof(HexBigInteger), log_logIndex.DataType);
Assert.False(log_logIndex.Ignore);
Assert.False(log_logIndex.IsKey);
Assert.False(log_logIndex.IsFacetable);
Assert.False(log_logIndex.IsFilterable);
Assert.False(log_logIndex.IsSearchable);
Assert.False(log_logIndex.IsSortable);
Assert.Equal(filterLog.LogIndex, log_logIndex.LogValueCallback(filterLog));
Assert.NotNull(log_transactionHash);
Assert.Equal(typeof(string), log_transactionHash.DataType);
Assert.False(log_transactionHash.Ignore);
Assert.False(log_transactionHash.IsKey);
Assert.False(log_transactionHash.IsFacetable);
Assert.False(log_transactionHash.IsFilterable);
Assert.True(log_transactionHash.IsSearchable);
Assert.False(log_transactionHash.IsSortable);
Assert.Equal(filterLog.TransactionHash, log_transactionHash.LogValueCallback(filterLog));
Assert.NotNull(log_transactionIndex);
Assert.Equal(typeof(HexBigInteger), log_transactionIndex.DataType);
Assert.False(log_transactionIndex.Ignore);
Assert.False(log_transactionIndex.IsKey);
Assert.False(log_transactionIndex.IsFacetable);
Assert.False(log_transactionIndex.IsFilterable);
Assert.False(log_transactionIndex.IsSearchable);
Assert.False(log_transactionIndex.IsSortable);
Assert.Equal(filterLog.TransactionIndex, log_transactionIndex.LogValueCallback(filterLog));
Assert.NotNull(log_blockHash);
Assert.Equal(typeof(string), log_blockHash.DataType);
Assert.False(log_blockHash.Ignore);
Assert.False(log_blockHash.IsKey);
Assert.False(log_blockHash.IsFacetable);
Assert.False(log_blockHash.IsFilterable);
Assert.False(log_blockHash.IsSearchable);
Assert.False(log_blockHash.IsSortable);
Assert.Equal(filterLog.BlockHash, log_blockHash.LogValueCallback(filterLog));
Assert.NotNull(log_blockNumber);
Assert.Equal(typeof(HexBigInteger), log_blockNumber.DataType);
Assert.False(log_blockNumber.Ignore);
Assert.False(log_blockNumber.IsKey);
Assert.False(log_blockNumber.IsFacetable);
Assert.True(log_blockNumber.IsFilterable);
Assert.True(log_blockNumber.IsSearchable);
Assert.True(log_blockNumber.IsSortable);
Assert.Equal(filterLog.BlockNumber, log_blockNumber.LogValueCallback(filterLog));
Assert.NotNull(log_address);
Assert.Equal(typeof(string), log_address.DataType);
Assert.False(log_address.Ignore);
Assert.False(log_address.IsKey);
Assert.False(log_address.IsFacetable);
Assert.True(log_address.IsFilterable);
Assert.True(log_address.IsSearchable);
Assert.True(log_address.IsSortable);
Assert.Equal(filterLog.Address, log_address.LogValueCallback(filterLog));
}
public void BuildsExpectedIndexForCodeGeneratedEventDto()
{
var searchIndex = new EventIndexDefinition <DepositedEventDTO>();
var depositedEventDto = new DepositedEventDTO
{
NewBalance = new HexBigInteger("100"),
Value = new HexBigInteger("10"),
Sender = "adsfadsfasdfasdf",
Detail = new DepositDetailDTO
{
Currency = "GBP",
Timestamp = DateTimeOffset.UnixEpoch.ToUnixTimeSeconds(),
Categories = new List <CategoryDTO>
{
new CategoryDTO {
Name = "Dodgy"
},
new CategoryDTO {
Name = "International"
}
},
Tags = new List <string> {
"A", "B"
}
}
};
var filterLog = new FilterLog
{
Type = "type",
Address = "address",
BlockHash = "block_hash",
BlockNumber = new HexBigInteger(101),
TransactionHash = "transaction_hash",
TransactionIndex = new HexBigInteger(3),
LogIndex = new HexBigInteger(9),
Removed = false
};
var eventLog = new EventLog <DepositedEventDTO>(depositedEventDto, filterLog);
Assert.Equal("Deposited", searchIndex.IndexName);
Assert.Equal(18, searchIndex.Fields.Length);
searchIndex
.Assertions(eventLog)
.HasField(nameof(depositedEventDto.Sender),
f => f.IsString(),
f => f.HasFlags(isSearchable: true, isFacetable: true, isFilterable: true, isSortable: true),
f => f.ReturnsValue(depositedEventDto.Sender))
.HasField(nameof(depositedEventDto.Value),
f => f.DataType <BigInteger>(),
f => f.HasFlags(),
f => f.ReturnsValue(depositedEventDto.Value))
.HasField(nameof(depositedEventDto.NewBalance),
f => f.DataType <BigInteger>(),
f => f.HasFlags(),
f => f.ReturnsValue(depositedEventDto.NewBalance))
.HasField("Detail.Currency",
f => f.IsString(),
f => f.HasFlags(isSearchable: true, isFilterable: true, isFacetable: true),
f => f.ReturnsValue(depositedEventDto.Detail.Currency))
.HasField("Detail.Categories.Name",
f => f.IsString(),
f => f.ReturnsValue <string[]>(categoryNameArray =>
{
var x = depositedEventDto.Detail.Categories.Select(cat => cat.Name).ToCommaSeparatedString();
var y = categoryNameArray.ToCommaSeparatedString();
return(x, y);
}))
.HasField("Detail.Tags",
f => f.DataType <List <string> >(),
f => f.HasFlags(isCollection: true),
f => f.ReturnsValue <string[]>(tags =>
{
var x = depositedEventDto.Detail.Tags.ToCommaSeparatedString();
var y = tags.ToCommaSeparatedString();
return(x, y);
}))
.HasField(PresetSearchFieldName.log_key,
f => f.IsString(),
f => f.HasFlags(isKey: true, isSortable: true),
f => f.ReturnsValue(filterLog.Key()))
.HasField(PresetSearchFieldName.log_removed,
f => f.DataType <bool>(),
f => f.HasFlags(isFilterable: true, isSortable: true),
f => f.ReturnsValue(filterLog.Removed))
.HasField(PresetSearchFieldName.log_type,
f => f.IsString(),
f => f.HasFlags(isFilterable: true, isSortable: true),
f => f.ReturnsValue(filterLog.Type))
.HasField(PresetSearchFieldName.log_log_index,
f => f.IsHexBigInteger(),
f => f.HasFlags(isFilterable: true),
f => f.ReturnsValue(filterLog.LogIndex))
.HasField(PresetSearchFieldName.log_transaction_hash,
f => f.IsString(),
f => f.HasFlags(isSearchable: true, isFilterable: true, isFacetable: true),
f => f.ReturnsValue(filterLog.TransactionHash))
.HasField(PresetSearchFieldName.log_transaction_index,
f => f.IsHexBigInteger(),
f => f.HasFlags(isFilterable: true),
f => f.ReturnsValue(filterLog.TransactionIndex))
.HasField(PresetSearchFieldName.log_block_hash,
f => f.IsString(),
f => f.HasFlags(),
f => f.ReturnsValue(filterLog.BlockHash))
.HasField(PresetSearchFieldName.log_block_number,
f => f.IsHexBigInteger(),
f => f.HasFlags(isFilterable: true, isSearchable: true, isSortable: true, isFacetable: true),
f => f.ReturnsValue(filterLog.BlockNumber))
.HasField(PresetSearchFieldName.log_address,
f => f.IsString(),
f => f.HasFlags(isFilterable: true, isSearchable: true, isSortable: true, isFacetable: true),
f => f.ReturnsValue(filterLog.Address))
.HasField(PresetSearchFieldName.log_topics,
f => f.IsString(),
f => f.HasFlags(isFilterable: true, isSearchable: true, isFacetable: true, isCollection: true),
f => f.ReturnsValue(filterLog.Topics));
}
