protected void CreateShouldReturnBindableMinMaxFilterViewModelWithValuesFromQueryRequest(
Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression,
Item item,
int?currentValue,
string text,
MinMaxFilter queryRequestFilter)
{
// arrange
var expected = new BindableMinMaxFilterViewModel(expectedBindingExpression)
{
Min = queryRequestFilter.Min,
Max = queryRequestFilter.Max,
Current = currentValue.ToString(),
Text = text,
IsEnabled = true
};
var searchQueryRequest = new SearchQueryRequest();
SetValueByExpression(expectedBindingExpression, searchQueryRequest, queryRequestFilter);
// act
IEnumerable <FilterViewModelBase> result = this.AdditionalFilterViewModelsFactory.Create(item, searchQueryRequest);
//assert
Assert.IsNotNull(result);
Assert.IsNotEmpty(result);
Assert.That(result, Has.One.Matches <FilterViewModelBase>(x => MatchBindableMinMaxFilterViewModel(x, expected)));
}
public void MapToQueryItemShouldMapMapTier(int mapTier)
{
var item = new MapItem(ItemRarity.Normal)
{
Tier = mapTier
};
SearchQueryRequest result = this.mapItemSearchQueryRequestMapper.MapToQueryRequest(item) as SearchQueryRequest;
MinMaxFilter mapTierFilter = result.Query.Filters.MapFilters.MapTier;
Assert.NotNull(mapTierFilter);
Assert.That(mapTierFilter.Min, Is.EqualTo(mapTier));
Assert.That(mapTierFilter.Max, Is.EqualTo(mapTier));
}
public void MapToQueryRequestShouldMapGemQuality(int expected)
{
var item = new GemItem
{
Quality = expected
};
SearchQueryRequest result = this.gemItemSearchQueryRequestMapper.MapToQueryRequest(item) as SearchQueryRequest;
MinMaxFilter qualityFilter = result.Query.Filters.MiscFilters.Quality;
Assert.IsNotNull(qualityFilter);
Assert.That(qualityFilter.Min, Is.EqualTo(expected));
Assert.IsNull(qualityFilter.Max);
}
public void CreateShouldReturnGemLevelFilterViewModelWithValuesFromSearchQueryRequest()
{
Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MiscFilters.GemLevel;
var gemItem = new GemItem
{
Level = 11
};
var queryRequestFilter = new MinMaxFilter
{
Min = 5,
Max = 20
};
this.CreateShouldReturnBindableMinMaxFilterViewModelWithValuesFromQueryRequest(expectedBindingExpression, gemItem, gemItem.Level, Resources.GemLevelColumn, queryRequestFilter);
}
public void CreateShouldReturnQualityFilterViewModelWithValuesFromSearchQueryRequest()
{
Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MiscFilters.Quality;
var gemItem = new GemItem
{
Quality = 11
};
var queryRequestFilter = new MinMaxFilter
{
Min = 10,
Max = 17
};
this.CreateShouldReturnBindableMinMaxFilterViewModelWithValuesFromQueryRequest(expectedBindingExpression, gemItem, gemItem.Quality, Resources.QualityColumn, queryRequestFilter);
}
public void CreateShouldReturnQualityFilterViewModelWithValuesFromSearchQueryRequest()
{
Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MiscFilters.Quality;
var flaskItem = new FlaskItem(ItemRarity.Unique)
{
Quality = 19
};
var queryRequestFilter = new MinMaxFilter
{
Min = 15,
Max = 20
};
this.CreateShouldReturnBindableMinMaxFilterViewModelWithValuesFromQueryRequest(expectedBindingExpression, flaskItem, flaskItem.Quality, Resources.QualityColumn, queryRequestFilter);
}
public void CreateShouldReturnItemQuantityFilterViewModelWithValuesFromQueryRequest()
{
Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MapFilters.MapIncreasedItemQuantity;
var mapItem = new MapItem(ItemRarity.Rare)
{
ItemQuantity = 79
};
var queryRequestFilter = new MinMaxFilter
{
Min = 65,
Max = 90
};
this.CreateShouldReturnBindableMinMaxFilterViewModel(expectedBindingExpression, mapItem, mapItem.ItemQuantity, Resources.MapItemQuantity);
}
public void CreateShouldReturnMapTierFilterViewModelWithValuesFromQueryRequest()
{
Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MapFilters.MapTier;
var mapItem = new MapItem(ItemRarity.Rare)
{
Tier = 6
};
var queryRequestFilter = new MinMaxFilter
{
Min = 4,
Max = 8
};
this.CreateShouldReturnBindableMinMaxFilterViewModel(expectedBindingExpression, mapItem, mapItem.Tier, Resources.MapTier);
}
public void CreateShouldReturnMonsterPackSizeFilterViewModelWithValuesFromQueryRequest()
{
Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MapFilters.MapPacksize;
var mapItem = new MapItem(ItemRarity.Rare)
{
MonsterPackSize = 35
};
var queryRequestFilter = new MinMaxFilter
{
Min = 20,
Max = 40
};
this.CreateShouldReturnBindableMinMaxFilterViewModel(expectedBindingExpression, mapItem, mapItem.MonsterPackSize, Resources.MapMonsterPacksize);
}
public void CreateShouldReturnGemExperiencePercentFilterViewModelWithValuesFromSearchQueryRequest()
{
Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MiscFilters.GemLevelProgress;
var gemItem = new GemItem
{
ExperiencePercent = 52
};
var queryRequestFilter = new MinMaxFilter
{
Min = 47,
Max = 90
};
this.CreateShouldReturnBindableMinMaxFilterViewModelWithValuesFromQueryRequest(expectedBindingExpression, gemItem, gemItem.ExperiencePercent, Resources.GemExperiencePercentColumn, queryRequestFilter);
}
public void CreateShouldReturnQualityFilterViewModelWithValuesFromSearchQueryRequest()
{
// arrange
Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MiscFilters.Quality;
var equippableItem = new EquippableItem(ItemRarity.Unique)
{
Quality = 7
};
var queryRequestFilter = new MinMaxFilter
{
Min = 4,
Max = 10
};
// act & assert
this.CreateShouldReturnBindableMinMaxFilterViewModelWithValuesFromQueryRequest(expectedBindingExpression, equippableItem, equippableItem.Quality, Resources.QualityColumn, queryRequestFilter);
}
private static IFilter GetFilter(FilterViewModelBase filterViewModel)
{
IFilter filter = null;
if (filterViewModel is BindableSocketsFilterViewModel socketsFilterViewModel)
{
if (socketsFilterViewModel.IsEnabled == true)
{
filter = new SocketsFilter
{
Min = socketsFilterViewModel.Min,
Max = GetMaxValue(socketsFilterViewModel),
Red = socketsFilterViewModel.Red,
Green = socketsFilterViewModel.Green,
Blue = socketsFilterViewModel.Blue,
White = socketsFilterViewModel.White
};
}
}
else if (filterViewModel is IMinMaxFilterViewModel minMaxFilterViewModel)
{
if (minMaxFilterViewModel.IsEnabled == true)
{
filter = new MinMaxFilter
{
Min = minMaxFilterViewModel.Min,
Max = GetMaxValue(minMaxFilterViewModel)
};
}
}
else
{
if (filterViewModel.IsEnabled.HasValue)
{
filter = new BoolOptionFilter
{
Option = filterViewModel.IsEnabled.Value
};
}
}
return(filter);
}
public void CreateShouldMapAdditionalMinMaxFilterToQuery(int?minValue, int?maxValue, int?expectedMinValue, int?expectedMaxValue)
{
BindableMinMaxFilterViewModel additionalFilter = new BindableMinMaxFilterViewModel(x => x.Query.Filters.MiscFilters.Quality)
{
Min = minValue,
Max = maxValue,
IsEnabled = true
};
var advancedFiltersViewModel = GetAdvancedFiltersViewModel(null, new[] { additionalFilter });
SearchQueryRequest result = this.queryRequestFactory.Create(new SearchQueryRequest(), advancedFiltersViewModel) as SearchQueryRequest;
Assert.NotNull(result);
MinMaxFilter qualityFilter = result.Query.Filters.MiscFilters.Quality;
Assert.NotNull(qualityFilter);
Assert.That(qualityFilter.Min, Is.EqualTo(expectedMinValue));
Assert.That(qualityFilter.Max, Is.EqualTo(expectedMaxValue));
}
public async Task <IActionResult> GetAll([FromQuery(Name = "offset")] int?offset,
[FromQuery(Name = "amount")] int?amount,
[FromQuery(Name = "history")] bool?includeHistory,
[FromQuery(Name = "elo-filter")] string eloFilter,
[FromQuery(Name = "winrate-filter")] string winrateFilter)
{
bool loadHistory = (includeHistory.HasValue) ? includeHistory.Value : false;
var requestOptions = new RequestOptions()
{
Count = amount,
Offset = offset,
IncludeMatchHistory = loadHistory,
EloFilter = MinMaxFilter.TryParse(eloFilter),
WinRateFilter = MinMaxFilter.TryParse(winrateFilter)
};
IEnumerable <Cat> cats = await CatService.GetAll(requestOptions).ConfigureAwait(false);
var response = new CommonResponse <CatsResponse>(ResponseCode.Success, "Ok", cats.ToApiModel());
return(Ok(response));
}
public void MapQueryItemShouldMapItemLevelIfThresholdIsReached()
{
const int itemLevel = 86;
var item = new EquippableItem(ItemRarity.Normal)
{
ItemLevel = itemLevel
};
this.ItemSearchOptionsMock.Setup(x => x.CurrentValue)
.Returns(new ItemSearchOptions
{
ItemLevelThreshold = itemLevel,
League = new League()
});
SearchQueryRequest result = this.equippableItemToQueryRequestMapper.MapToQueryRequest(item) as SearchQueryRequest;
MinMaxFilter itemLevelFilter = result.Query.Filters.MiscFilters.ItemLevel;
Assert.NotNull(itemLevelFilter);
Assert.That(itemLevelFilter.Min, Is.EqualTo(itemLevel));
Assert.IsNull(itemLevelFilter.Max);
}
protected virtual BindableMinMaxFilterViewModel CreateBindableMinMaxFilterViewModel(Expression <Func <SearchQueryRequest, IFilter> > bindingExpression, string text, int currentValue, MinMaxFilter queryRequestFilter)
{
var result = new BindableMinMaxFilterViewModel(bindingExpression)
{
Current = currentValue.ToString(),
Text = text
};
if (queryRequestFilter != null)
{
result.Min = queryRequestFilter.Min;
result.Max = queryRequestFilter.Max;
result.IsEnabled = true;
}
else
{
result.Min = currentValue;
result.Max = currentValue;
}
return(result);
}
public void AddFilter(string id, MinMaxFilter filter)
{
filters[id] = filter;
}
private static SearchQueryRequest GetQueryRequestWithStatFilter(string statId, MinMaxFilter value)
{
return(new SearchQueryRequest
{
Query =
{
Stats =
{
new StatFilters
{
Filters =
{
new StatFilter
{
Id = statId,
Value = value
}
}
}
}
}
});
}
