protected virtual IFilter ConvertPriceRangeFilter(PriceRangeFilter priceRangeFilter, IList <string> valueIds, ProductIndexedSearchCriteria criteria)
{
IFilter result = null;
if (string.IsNullOrEmpty(criteria.Currency) || priceRangeFilter.Currency.EqualsInvariant(criteria.Currency))
{
var knownValues = priceRangeFilter.Values
?.Where(v => valueIds.Contains(v.Id, StringComparer.OrdinalIgnoreCase))
.ToArray();
if (knownValues != null && knownValues.Any())
{
var filters = knownValues
.Select(v => FiltersHelper.CreatePriceRangeFilter(priceRangeFilter.Currency, criteria.Pricelists, v.Lower, v.Upper, v.IncludeLower, v.IncludeUpper))
.Where(f => f != null)
.ToList();
result = filters.Or();
}
else
{
// Unknown term values should produce empty result
result = new IdsFilter {
Values = new[] { string.Empty }
};
}
}
return(result);
}
public SearchCriteria()
{
// Set defaults
Zipcode = "92612";
vdpPrice = "";
vdpMileage = "";
RadiusMiles = 100;
Skip = 0;
Take = 12;
Sort = new Dto.Sort
{
By = Common.Sort.By.BestMatch,
Direction = Common.Sort.Direction.Ascending
};
MakeModelComboFilter = new MakeModelComboFilter();
CategoryMakeComboFilter = new CategoryMakeComboFilter();
NewStatusFilter = new NewStatusFilter();
CityMpgFilter = new CityMpgFilter();
HighwayMpgFilter = new HighwayMpgFilter();
PriceRangeFilter = new PriceRangeFilter();
MileageRangeFilter = new MileageRangeFilter();
YearRangeFilter = new YearRangeFilter();
CylindersFilter = new CylindersFilter();
DriveTypeFilter = new DriveTypeFilter();
FuelTypeFilter = new FuelTypeFilter();
TransmissionTypeFilter = new TransmissionTypeFilter();
OptionBitsFilter = new OptionBitsFilter();
TrimIdFilter = new TrimIdFilter();
}
public void FilterPriceTest()
{
var inv = TestInitialize();
var priceRangeFilter = new PriceRangeFilter(100, 200);
var filtered = inv.Filter(new List <IFilter> {
priceRangeFilter
});
CollectionAssert.Contains(filtered, inv.Items[4]);
}
protected virtual Aggregation GetPriceRangeAggregation(PriceRangeFilter priceRangeFilter, IList <AggregationResponse> aggregationResponses)
{
var result = new Aggregation
{
AggregationType = "pricerange",
Field = priceRangeFilter.Key,
Items = GetRangeAggregationItems(priceRangeFilter.Key, priceRangeFilter.Values, aggregationResponses).ToArray(),
};
return(result);
}
public static ISearchFilter Convert(this ISearchFilterService helper, ISearchFilter filter, string[] keys)
{
// get values that we have filters set for
var values = from v in filter.GetValues() where keys.Contains(v.Id) select v;
var attributeFilter = filter as AttributeFilter;
if (attributeFilter != null)
{
var newFilter = new AttributeFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType <AttributeFilterValue>().ToArray();
return(newFilter);
}
var rangeFilter = filter as RangeFilter;
if (rangeFilter != null)
{
var newFilter = new RangeFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType <RangeFilterValue>().ToArray();
return(newFilter);
}
var priceRangeFilter = filter as PriceRangeFilter;
if (priceRangeFilter != null)
{
var newFilter = new PriceRangeFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType <RangeFilterValue>().ToArray();
return(newFilter);
}
var categoryFilter = filter as CategoryFilter;
if (categoryFilter != null)
{
var newFilter = new CategoryFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType <CategoryFilterValue>().ToArray();
return(newFilter);
}
return(null);
}
private static IBrowseFilter ConvertToFilter(AggregationProperty property, int order)
{
IBrowseFilter result = null;
switch (property.Type)
{
case _attributeType:
result = new AttributeFilter
{
Order = order,
Key = property.Name,
FacetSize = property.Size,
Values = property.Values?.OrderBy(v => v, StringComparer.OrdinalIgnoreCase).Select(v => new AttributeFilterValue {
Id = v
}).ToArray(),
};
break;
case _rangeType:
result = new RangeFilter
{
Order = order,
Key = property.Name,
Values = GetRangeFilterValues(property.Values),
};
break;
case _priceRangeType:
result = new PriceRangeFilter
{
Order = order,
Currency = property.Currency,
Values = GetRangeFilterValues(property.Values),
};
break;
}
return(result);
}
private static void CreatePriceFilters(FilteredBrowsing browsing)
{
var filters = browsing.Prices != null ? new List <PriceRangeFilter>(browsing.Prices) : new List <PriceRangeFilter>();
var vals = new List <RangeFilterValue>();
var filter = new PriceRangeFilter {
Currency = "USD", IsLocalized = false
};
vals.Add(CreateRange("Under $100", "under-100", String.Empty, "100", "en"));
vals.Add(CreateRange("$100 - $200", "100-200", "100", "200", "en"));
vals.Add(CreateRange("$200 - $600", "200-600", "200", "600", "en"));
vals.Add(CreateRange("$600 - $1000", "600-1000", "600", "1000", "en"));
vals.Add(CreateRange("Over $1000", "over-1000", "1000", String.Empty, "en"));
filter.Values = vals.ToArray();
filters.Add(filter);
vals = new List <RangeFilterValue>();
filter = new PriceRangeFilter {
Currency = "EUR", IsLocalized = false
};
vals.Add(CreateRange("Under 100€", "under-100", String.Empty, "100", "en"));
vals.Add(CreateRange("100€ - 200€", "100-200", "100", "200", "en"));
vals.Add(CreateRange("200€ - 600€", "200-600", "200", "600", "en"));
vals.Add(CreateRange("600€ - 1000€", "600-1000", "600", "1000", "en"));
vals.Add(CreateRange("Over 1000€", "over-1000", "1000", String.Empty, "en"));
filter.Values = vals.ToArray();
filters.Add(filter);
browsing.Prices = filters.ToArray();
}
public void Can_get_item_facets_lucene()
{
var scope = "default";
var queryBuilder = new LuceneSearchQueryBuilder();
var conn = new SearchConnection(_LuceneStorageDir, scope);
var provider = new LuceneSearchProvider(queryBuilder, conn);
Debug.WriteLine("Lucene connection: {0}", conn.ToString());
if (Directory.Exists(_LuceneStorageDir))
{
Directory.Delete(_LuceneStorageDir, true);
}
SearchHelper.CreateSampleIndex(provider, scope);
var criteria = new CatalogIndexedSearchCriteria
{
SearchPhrase = "",
IsFuzzySearch = true,
Catalog = "goods",
RecordsToRetrieve = 10,
StartingRecord = 0,
Currency = "USD",
Pricelists = new[] { "default" }
};
var filter = new AttributeFilter {
Key = "Color"
};
filter.Values = new[]
{
new AttributeFilterValue {
Id = "red", Value = "red"
},
new AttributeFilterValue {
Id = "blue", Value = "blue"
},
new AttributeFilterValue {
Id = "black", Value = "black"
}
};
var rangefilter = new RangeFilter {
Key = "size"
};
rangefilter.Values = new[]
{
new RangeFilterValue {
Id = "0_to_5", Lower = "0", Upper = "5"
},
new RangeFilterValue {
Id = "5_to_10", Lower = "5", Upper = "10"
}
};
var priceRangefilter = new PriceRangeFilter {
Currency = "usd"
};
priceRangefilter.Values = new[]
{
new RangeFilterValue {
Id = "0_to_100", Lower = "0", Upper = "100"
},
new RangeFilterValue {
Id = "100_to_700", Lower = "100", Upper = "700"
}
};
criteria.Add(filter);
criteria.Add(rangefilter);
criteria.Add(priceRangefilter);
var results = provider.Search(scope, criteria);
Assert.True(results.DocCount == 4, String.Format("Returns {0} instead of 4", results.DocCount));
var redCount = GetFacetCount(results, "Color", "red");
Assert.True(redCount == 2, String.Format("Returns {0} facets of red instead of 2", redCount));
var priceCount = GetFacetCount(results, "Price", "0_to_100");
Assert.True(priceCount == 2, String.Format("Returns {0} facets of 0_to_100 prices instead of 2", priceCount));
var priceCount2 = GetFacetCount(results, "Price", "100_to_700");
Assert.True(priceCount2 == 2, String.Format("Returns {0} facets of 100_to_700 prices instead of 2", priceCount2));
var sizeCount = GetFacetCount(results, "size", "0_to_5");
Assert.True(sizeCount == 2, String.Format("Returns {0} facets of 0_to_5 size instead of 2", sizeCount));
var sizeCount2 = GetFacetCount(results, "size", "5_to_10");
Assert.True(sizeCount2 == 1, String.Format("Returns {0} facets of 5_to_10 size instead of 1", sizeCount2)); // only 1 result because upper bound is not included
var outlineCount = results.Documents[0].Documents[0]["__outline"].Values.Count();
Assert.True(outlineCount == 2, String.Format("Returns {0} outlines instead of 2", outlineCount));
Directory.Delete(_LuceneStorageDir, true);
}
public void Can_get_item_multiple_filters_lucene()
{
var scope = "default";
var queryBuilder = new LuceneSearchQueryBuilder();
var conn = new SearchConnection(_LuceneStorageDir, scope);
var provider = new LuceneSearchProvider(queryBuilder, conn);
Debug.WriteLine("Lucene connection: {0}", conn.ToString());
if (Directory.Exists(_LuceneStorageDir))
{
Directory.Delete(_LuceneStorageDir, true);
}
SearchHelper.CreateSampleIndex(provider, scope);
var criteria = new CatalogIndexedSearchCriteria
{
SearchPhrase = "",
IsFuzzySearch = true,
Catalog = "goods",
RecordsToRetrieve = 10,
StartingRecord = 0,
Currency = "USD",
Pricelists = new[] { "default" }
};
var colorFilter = new AttributeFilter {
Key = "Color"
};
colorFilter.Values = new[]
{
new AttributeFilterValue {
Id = "red", Value = "red"
},
new AttributeFilterValue {
Id = "blue", Value = "blue"
},
new AttributeFilterValue {
Id = "black", Value = "black"
}
};
var filter = new AttributeFilter {
Key = "Color"
};
filter.Values = new[]
{
new AttributeFilterValue {
Id = "black", Value = "black"
}
};
var rangefilter = new RangeFilter {
Key = "size"
};
rangefilter.Values = new[]
{
new RangeFilterValue {
Id = "0_to_5", Lower = "0", Upper = "5"
},
new RangeFilterValue {
Id = "5_to_10", Lower = "5", Upper = "11"
}
};
var priceRangefilter = new PriceRangeFilter {
Currency = "usd"
};
priceRangefilter.Values = new[]
{
new RangeFilterValue {
Id = "100_to_700", Lower = "100", Upper = "700"
}
};
criteria.Add(colorFilter);
criteria.Add(priceRangefilter);
// add applied filters
criteria.Apply(filter);
//criteria.Apply(rangefilter);
//criteria.Apply(priceRangefilter);
var results = provider.Search(scope, criteria);
var blackCount = GetFacetCount(results, "Color", "black");
Assert.True(blackCount == 1, String.Format("Returns {0} facets of black instead of 2", blackCount));
//Assert.True(results.DocCount == 1, String.Format("Returns {0} instead of 1", results.DocCount));
Directory.Delete(_LuceneStorageDir, true);
}
protected virtual AggregationRequest GetPriceRangeFilterValueAggregationRequest(PriceRangeFilter priceRangeFilter, RangeFilterValue value, IEnumerable <IFilter> existingFilters, IList <string> pricelists)
{
var valueFilter = FiltersHelper.CreatePriceRangeFilter(priceRangeFilter.Currency, pricelists, value.Lower, value.Upper, value.IncludeLower, value.IncludeUpper);
var result = new TermAggregationRequest
{
Id = $"{priceRangeFilter.Key}-{value.Id}",
Filter = existingFilters.And(valueFilter)
};
return(result);
}
protected virtual IList <AggregationRequest> GetPriceRangeFilterAggregationRequests(PriceRangeFilter priceRangeFilter, ProductIndexedSearchCriteria criteria, IList <IFilter> existingFilters)
{
var result = priceRangeFilter.Values?.Select(v => GetPriceRangeFilterValueAggregationRequest(priceRangeFilter, v, existingFilters, criteria.Pricelists)).ToList();
return(result);
}
public void Can_index_product_demo_data_and_search(string providerType)
{
var provider = GetSearchProvider(providerType, _scope);
RebuildIndex(provider, CatalogItemSearchCriteria.DocType);
// find all products in the category
var criteria = new CatalogItemSearchCriteria
{
Catalog = GetCatalogId("electronics"),
Currency = "USD"
};
// Add facets
var colorFacet = new AttributeFilter {
Key = "color"
};
var brandFacet = new AttributeFilter
{
Key = "brand",
IsLocalized = true,
Values = new[]
{
new AttributeFilterValue {
Id = "Apple", Value = "Apple"
},
new AttributeFilterValue {
Id = "Asus", Value = "Asus"
},
new AttributeFilterValue {
Id = "Samsung", Value = "Samsung"
}
}
};
var sizeFacet = new RangeFilter
{
Key = "display_size",
Values = new[]
{
new RangeFilterValue {
Id = "0_to_5", Lower = "0", Upper = "5"
},
new RangeFilterValue {
Id = "5_to_10", Lower = "5", Upper = "10"
}
}
};
var priceFacet = new PriceRangeFilter
{
Currency = "USD",
Values = new[]
{
new RangeFilterValue {
Id = "under-100", Upper = "100"
},
new RangeFilterValue {
Id = "200-600", Lower = "200", Upper = "600"
}
}
};
criteria.Add(brandFacet);
criteria.Add(colorFacet);
criteria.Add(sizeFacet);
criteria.Add(priceFacet);
var ibs = GetItemBrowsingService(provider);
var searchResults = ibs.SearchItems(_scope, criteria, ItemResponseGroup.ItemLarge);
Assert.True(searchResults.TotalCount > 0, $"Didn't find any products using {providerType} provider");
Assert.True(searchResults.Aggregations.Any(), $"Didn't find any aggregations using {providerType} provider");
Assert.True(GetFacetValuesCount(searchResults, "color") > 0, $"Didn't find any aggregation value for Color using {providerType} provider");
Assert.Equal(0, GetFacetValue(searchResults, "brand", "Apple"));
Assert.Equal(2, GetFacetValue(searchResults, "brand", "Asus"));
Assert.Equal(5, GetFacetValue(searchResults, "brand", "Samsung"));
criteria = new CatalogItemSearchCriteria {
Currency = "USD", Locale = "en-us", SearchPhrase = "sony"
};
searchResults = ibs.SearchItems(_scope, criteria, ItemResponseGroup.ItemLarge);
Assert.True(searchResults.TotalCount > 0);
}
public void Can_index_product_demo_data_and_search(string providerType)
{
var scope = "test";
var provider = GetSearchProvider(providerType, scope);
//if (provider is ElasticSearchProvider)
// (provider as ElasticSearchProvider).AutoCommitCount = 1; // commit every one document
provider.RemoveAll(scope, "");
var controller = GetSearchIndexController(provider);
controller.RemoveIndex(scope, CatalogItemSearchCriteria.DocType);
controller.BuildIndex(scope, CatalogItemSearchCriteria.DocType, x => { return; });
// sleep for index to be commited
Thread.Sleep(5000);
// get catalog id by name
var catalogRepo = GetCatalogRepository();
var catalog = catalogRepo.Catalogs.SingleOrDefault(x => x.Name.Equals("electronics", StringComparison.OrdinalIgnoreCase));
// find all prodducts in the category
var catalogCriteria = new CatalogItemSearchCriteria()
{
Catalog = catalog.Id,
Currency = "USD"
};
// Add all filters
var brandFilter = new AttributeFilter {
Key = "brand"
};
var filter = new AttributeFilter {
Key = "color", IsLocalized = true
};
filter.Values = new[]
{
new AttributeFilterValue {
Id = "Red", Value = "Red"
},
new AttributeFilterValue {
Id = "Gray", Value = "Gray"
},
new AttributeFilterValue {
Id = "Black", Value = "Black"
}
};
var rangefilter = new RangeFilter {
Key = "size"
};
rangefilter.Values = new[]
{
new RangeFilterValue {
Id = "0_to_5", Lower = "0", Upper = "5"
},
new RangeFilterValue {
Id = "5_to_10", Lower = "5", Upper = "10"
}
};
var priceRangefilter = new PriceRangeFilter {
Currency = "USD"
};
priceRangefilter.Values = new[]
{
new RangeFilterValue {
Id = "under-100", Upper = "100"
},
new RangeFilterValue {
Id = "200-600", Lower = "200", Upper = "600"
}
};
catalogCriteria.Add(filter);
catalogCriteria.Add(rangefilter);
catalogCriteria.Add(priceRangefilter);
catalogCriteria.Add(brandFilter);
var ibs = GetItemBrowsingService(provider);
var searchResults = ibs.SearchItems(scope, catalogCriteria, Domain.Catalog.Model.ItemResponseGroup.ItemLarge);
Assert.True(searchResults.TotalCount > 0, string.Format("Didn't find any products using {0} search", providerType));
Assert.True(searchResults.Aggregations.Count() > 0, string.Format("Didn't find any aggregations using {0} search", providerType));
var colorAggregation = searchResults.Aggregations.SingleOrDefault(a => a.Field.Equals("color", StringComparison.OrdinalIgnoreCase));
Assert.True(colorAggregation.Items.Where(x => x.Value.ToString().Equals("Red", StringComparison.OrdinalIgnoreCase)).SingleOrDefault().Count == 6);
Assert.True(colorAggregation.Items.Where(x => x.Value.ToString().Equals("Gray", StringComparison.OrdinalIgnoreCase)).SingleOrDefault().Count == 3);
Assert.True(colorAggregation.Items.Where(x => x.Value.ToString().Equals("Black", StringComparison.OrdinalIgnoreCase)).SingleOrDefault().Count == 13);
var brandAggregation = searchResults.Aggregations.SingleOrDefault(a => a.Field.Equals("brand", StringComparison.OrdinalIgnoreCase));
Assert.True(brandAggregation.Items.Where(x => x.Value.ToString().Equals("Beats By Dr Dre", StringComparison.OrdinalIgnoreCase)).SingleOrDefault().Count == 3);
var keywordSearchCriteria = new KeywordSearchCriteria(CatalogItemSearchCriteria.DocType)
{
Currency = "USD", Locale = "en-us", SearchPhrase = "sony"
};
searchResults = ibs.SearchItems(scope, keywordSearchCriteria, Domain.Catalog.Model.ItemResponseGroup.ItemLarge);
Assert.True(searchResults.TotalCount > 0);
}
public void Can_get_item_multiple_filters(string providerType)
{
var scope = _DefaultScope;
var provider = GetSearchProvider(providerType, scope);
SearchHelper.CreateSampleIndex(provider, scope);
var criteria = new CatalogItemSearchCriteria
{
SearchPhrase = "",
IsFuzzySearch = true,
Catalog = "goods",
RecordsToRetrieve = 10,
StartingRecord = 0,
Currency = "USD",
Pricelists = new[] { "default" }
};
var colorFilter = new AttributeFilter {
Key = "Color"
};
colorFilter.Values = new[]
{
new AttributeFilterValue {
Id = "red", Value = "red"
},
new AttributeFilterValue {
Id = "blue", Value = "blue"
},
new AttributeFilterValue {
Id = "black", Value = "black"
}
};
var filter = new AttributeFilter {
Key = "Color"
};
filter.Values = new[]
{
new AttributeFilterValue {
Id = "black", Value = "black"
}
};
var rangefilter = new RangeFilter {
Key = "size"
};
rangefilter.Values = new[]
{
new RangeFilterValue {
Id = "0_to_5", Lower = "0", Upper = "5"
},
new RangeFilterValue {
Id = "5_to_10", Lower = "5", Upper = "11"
}
};
var priceRangefilter = new PriceRangeFilter {
Currency = "usd"
};
priceRangefilter.Values = new[]
{
new RangeFilterValue {
Id = "100_to_700", Lower = "100", Upper = "700"
}
};
criteria.Add(colorFilter);
criteria.Add(rangefilter);
criteria.Add(priceRangefilter);
// add applied filters
criteria.Apply(filter);
criteria.Apply(rangefilter);
criteria.Apply(priceRangefilter);
var results = provider.Search <DocumentDictionary>(scope, criteria);
var blackCount = GetFacetCount(results, "Color", "black");
Assert.True(blackCount == 1, string.Format("Returns {0} facets of black instead of 1", blackCount));
var redCount = GetFacetCount(results, "Color", "red");
Assert.True(redCount == 2, string.Format("Returns {0} facets of black instead of 2", redCount));
var priceCount = GetFacetCount(results, "Price", "100_to_700");
Assert.True(priceCount == 1, string.Format("Returns {0} facets of 100_to_700 instead of 1", priceCount));
Assert.True(results.DocCount == 1, string.Format("Returns {0} instead of 1", results.DocCount));
}
public void Can_find_pricelists_prices(string providerType)
{
var scope = _DefaultScope;
var provider = GetSearchProvider(providerType, scope);
SearchHelper.CreateSampleIndex(provider, scope);
var criteria = new CatalogItemSearchCriteria
{
IsFuzzySearch = true,
Catalog = "goods",
RecordsToRetrieve = 10,
StartingRecord = 0,
Currency = "usd",
Pricelists = new string[] { "default", "sale" }
};
var priceRangefilter = new PriceRangeFilter {
Currency = "usd"
};
priceRangefilter.Values = new[]
{
new RangeFilterValue {
Id = "0_to_100", Lower = "0", Upper = "100"
},
new RangeFilterValue {
Id = "100_to_700", Lower = "100", Upper = "700"
}
};
criteria.Add(priceRangefilter);
var results = provider.Search <DocumentDictionary>(scope, criteria);
Assert.True(results.DocCount == 6, string.Format("Returns {0} instead of 6", results.DocCount));
var priceCount = GetFacetCount(results, "Price", "0_to_100");
Assert.True(priceCount == 2, string.Format("Returns {0} facets of 0_to_100 prices instead of 2", priceCount));
var priceCount2 = GetFacetCount(results, "Price", "100_to_700");
Assert.True(priceCount2 == 3, string.Format("Returns {0} facets of 100_to_700 prices instead of 3", priceCount2));
criteria = new CatalogItemSearchCriteria
{
IsFuzzySearch = true,
Catalog = "goods",
RecordsToRetrieve = 10,
StartingRecord = 0,
Currency = "usd",
Pricelists = new string[] { "sale", "default" }
};
criteria.Add(priceRangefilter);
results = provider.Search <DocumentDictionary>(scope, criteria);
Assert.True(results.DocCount == 6, string.Format("\"Sample Product\" search returns {0} instead of 6", results.DocCount));
var priceSaleCount = GetFacetCount(results, "Price", "0_to_100");
Assert.True(priceSaleCount == 3, string.Format("Returns {0} facets of 0_to_100 prices instead of 2", priceSaleCount));
var priceSaleCount2 = GetFacetCount(results, "Price", "100_to_700");
Assert.True(priceSaleCount2 == 2, string.Format("Returns {0} facets of 100_to_700 prices instead of 3", priceSaleCount2));
}
public void Can_get_item_facets(string providerType)
{
var scope = _DefaultScope;
var provider = GetSearchProvider(providerType, scope);
SearchHelper.CreateSampleIndex(provider, scope);
var criteria = new CatalogItemSearchCriteria
{
SearchPhrase = "",
IsFuzzySearch = true,
Catalog = "goods",
RecordsToRetrieve = 10,
StartingRecord = 0,
Currency = "USD",
Pricelists = new[] { "default" }
};
var filter = new AttributeFilter {
Key = "Color"
};
filter.Values = new[]
{
new AttributeFilterValue {
Id = "red", Value = "red"
},
new AttributeFilterValue {
Id = "blue", Value = "blue"
},
new AttributeFilterValue {
Id = "black", Value = "black"
}
};
var rangefilter = new RangeFilter {
Key = "size"
};
rangefilter.Values = new[]
{
new RangeFilterValue {
Id = "0_to_5", Lower = "0", Upper = "5"
},
new RangeFilterValue {
Id = "5_to_10", Lower = "5", Upper = "10"
}
};
var priceRangefilter = new PriceRangeFilter {
Currency = "usd"
};
priceRangefilter.Values = new[]
{
new RangeFilterValue {
Id = "0_to_100", Lower = "0", Upper = "100"
},
new RangeFilterValue {
Id = "100_to_700", Lower = "100", Upper = "700"
},
new RangeFilterValue {
Id = "over_700", Lower = "700"
},
new RangeFilterValue {
Id = "under_100", Upper = "100"
},
};
criteria.Add(filter);
criteria.Add(rangefilter);
criteria.Add(priceRangefilter);
var results = provider.Search <DocumentDictionary>(scope, criteria);
Assert.True(results.DocCount == 6, string.Format("Returns {0} instead of 6", results.DocCount));
var redCount = GetFacetCount(results, "Color", "red");
Assert.True(redCount == 3, string.Format("Returns {0} facets of red instead of 3", redCount));
var priceCount = GetFacetCount(results, "Price", "0_to_100");
Assert.True(priceCount == 2, string.Format("Returns {0} facets of 0_to_100 prices instead of 2", priceCount));
var priceCount2 = GetFacetCount(results, "Price", "100_to_700");
Assert.True(priceCount2 == 3, string.Format("Returns {0} facets of 100_to_700 prices instead of 3", priceCount2));
var priceCount3 = GetFacetCount(results, "Price", "over_700");
Assert.True(priceCount3 == 1, string.Format("Returns {0} facets of over_700 prices instead of 1", priceCount3));
var priceCount4 = GetFacetCount(results, "Price", "under_100");
Assert.True(priceCount4 == 2, string.Format("Returns {0} facets of priceCount4 prices instead of 2", priceCount4));
var sizeCount = GetFacetCount(results, "size", "0_to_5");
Assert.True(sizeCount == 3, string.Format("Returns {0} facets of 0_to_5 size instead of 3", sizeCount));
var sizeCount2 = GetFacetCount(results, "size", "5_to_10");
Assert.True(sizeCount2 == 1, string.Format("Returns {0} facets of 5_to_10 size instead of 1", sizeCount2)); // only 1 result because upper bound is not included
int outlineCount = 0;
var outlineObject = results.Documents.ElementAt(0)["__outline"]; // can be JArray or object[] depending on provider used
if (outlineObject is JArray)
{
outlineCount = (outlineObject as JArray).Count;
}
else
{
outlineCount = (outlineObject as object[]).Count();
}
Assert.True(outlineCount == 2, string.Format("Returns {0} outlines instead of 2", outlineCount));
}
