public void ReadGenericFilter_Empty()
{
var gf = new FilterCriteria[] { };
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("", entityRepos.Log);
var items = genericRepos.Load(gf);
Assert.AreEqual("Q, X", entityRepos.Log);
Assert.AreEqual("a1, a2, b1, b2", TestUtility.Dump(items));
Assert.AreEqual("IL", TestIListIQueryable(items));
Assert.AreEqual("Q, X", entityRepos.Log);
items = genericRepos.Read(gf, preferQuery: true);
Assert.AreEqual("Q, X, Q", entityRepos.Log);
Assert.AreEqual("a1, a2, b1, b2", TestUtility.Dump(items));
Assert.AreEqual("Q, X, Q, X", entityRepos.Log);
Assert.AreEqual("IQ", TestIListIQueryable(items));
Assert.AreEqual("Q, X, Q, X", entityRepos.Log);
}
public void ReadGenericFilter_FilterWithParameters()
{
var gf = new FilterCriteria[] { new FilterCriteria {
Filter = typeof(ContainsFilter).FullName, Value = new ContainsFilter {
Pattern = "a"
}
} };
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("", entityRepos.Log);
var items = genericRepos.Load(gf);
Assert.AreEqual("IL", TestIListIQueryable(items));
Assert.AreEqual("Q, QF, X", entityRepos.Log);
Assert.AreEqual("a1, a2", TestUtility.Dump(items));
Assert.AreEqual("Q, QF, X", entityRepos.Log);
items = genericRepos.Read(gf, preferQuery: true);
Assert.AreEqual("IQ", TestIListIQueryable(items));
Assert.AreEqual("Q, QF, X, Q, QF", entityRepos.Log);
Assert.AreEqual("a1, a2", TestUtility.Dump(items));
Assert.AreEqual("Q, QF, X, Q, QF, X", entityRepos.Log);
}
public void FilterGenericFilter_Empty()
{
var gf = Array.Empty <FilterCriteria>();
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("", entityRepos.Log);
var items = genericRepos.Filter(genericRepos.Query(), gf);
Assert.AreEqual("Q, X", entityRepos.Log);
Assert.AreEqual("a1, a2, b1, b2", TestUtility.Dump(items));
Assert.AreEqual("IL", TestIListIQueryable(items));
Assert.AreEqual("Q, X", entityRepos.Log);
items = genericRepos.FilterOrQuery(genericRepos.Query(), gf);
Assert.AreEqual("Q, X, Q", entityRepos.Log);
Assert.AreEqual("a1, a2, b1, b2", TestUtility.Dump(items));
Assert.AreEqual("Q, X, Q, X", entityRepos.Log);
Assert.AreEqual("IQ", TestIListIQueryable(items));
Assert.AreEqual("Q, X, Q, X", entityRepos.Log);
}
public void ReadGenericFilter_NonMaterialized()
{
var gf = new[] { new FilterCriteria {
Property = "Name", Operation = "StartsWith", Value = "b"
} };
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("", entityRepos.Log);
var items = genericRepos.Load(gf);
Assert.AreEqual("Q, X", entityRepos.Log);
Assert.AreEqual("b1, b2", TestUtility.Dump(items));
Assert.AreEqual("IL", TestIListIQueryable(items));
Assert.AreEqual("Q, X", entityRepos.Log);
items = genericRepos.Read(gf, preferQuery: true);
Assert.AreEqual("Q, X, Q", entityRepos.Log);
Assert.AreEqual("b1, b2", TestUtility.Dump(items));
Assert.AreEqual("Q, X, Q, X", entityRepos.Log);
Assert.AreEqual("b1, b2", TestUtility.Dump(items));
Assert.AreEqual("Q, X, Q, X, X", entityRepos.Log);
Assert.AreEqual("IQ", TestIListIQueryable(items));
Assert.AreEqual("Q, X, Q, X, X", entityRepos.Log);
}
public void FilterOperationWithID()
{
List <SimpleEntity> temp = new List <SimpleEntity>();
temp.Add(new SimpleEntity {
ID = new Guid("DA04CA2A-7AA0-4827-8F71-05047B0FB201"), Data = "a", Name = "1"
});
temp.Add(new SimpleEntity {
ID = new Guid("85ECBC94-2A9D-457C-934B-1117A7D72834"), Data = "b", Name = "2"
});
temp.Add(new SimpleEntity {
ID = new Guid("F440440A-993F-40B8-BE27-2ECA04FBE191"), Data = "c", Name = "3"
});
temp.Add(new SimpleEntity {
ID = new Guid("723FB608-052F-4696-A1D1-8A12BC19E69F"), Data = "d", Name = "4"
});
var entityRepos = new GenericFilterRepository(temp);
var genericRepos = NewRepos(entityRepos);
var gf_Greater = new[] { new FilterCriteria {
Property = "ID", Operation = "greater", Value = "85ECBC94-2A9D-457C-934B-1117A7D72834"
} };
var gf_GreaterEqual = new[] { new FilterCriteria {
Property = "ID", Operation = "greaterequal", Value = "85ECBC94-2A9D-457C-934B-1117A7D72834"
} };
var gf_Less = new[] { new FilterCriteria {
Property = "ID", Operation = "less", Value = "85ECBC94-2A9D-457C-934B-1117A7D72834"
} };
var gf_LessEqual = new[] { new FilterCriteria {
Property = "ID", Operation = "lessequal", Value = "85ECBC94-2A9D-457C-934B-1117A7D72834"
} };
string resultGreater = TypeAndNames(genericRepos.Filter(genericRepos.Query(), gf_Greater));
string resultGreaterEqual = TypeAndNames(genericRepos.Filter(genericRepos.Query(), gf_GreaterEqual));
string resultLess = TypeAndNames(genericRepos.Filter(genericRepos.Query(), gf_Less));
string resultLessEqual = TypeAndNames(genericRepos.Filter(genericRepos.Query(), gf_LessEqual));
Assert.AreEqual("IL: 1, 3", resultGreater);
Assert.AreEqual("IL: 1, 2, 3", resultGreaterEqual);
Assert.AreEqual("IL: 4", resultLess);
Assert.AreEqual("IL: 2, 4", resultLessEqual);
}
public void FilterGenericFilter_NotMatches()
{
Expression <Func <SimpleEntity, bool> > predicate = item => item.Name.StartsWith("a");
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("IQ: a1, a2", TypeAndNames(genericRepos.FilterOrQuery(genericRepos.Query(),
new[] { new FilterCriteria {
Filter = predicate.GetType().AssemblyQualifiedName, Operation = "Matches", Value = predicate
} })));
Assert.AreEqual("Q, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IQ: b1, b2", TypeAndNames(genericRepos.FilterOrQuery(genericRepos.Query(),
new[] { new FilterCriteria {
Filter = predicate.GetType().AssemblyQualifiedName, Operation = "NotMatches", Value = predicate
} })));
Assert.AreEqual("Q, X", entityRepos.Log); entityRepos._log.Clear();
}
public void ReadGenericFilter_NotLimitedToInterface()
{
var items = new[] {
new SimpleEntity {
Name = "1", Data = "ax"
},
new SimpleEntity {
Name = "2", Data = "ay"
},
new SimpleEntity {
Name = "3", Data = "bx"
},
new SimpleEntity {
Name = "4", Data = "by"
},
new SimpleEntity {
Name = "11", Data = "ax0"
},
new SimpleEntity {
Name = "12", Data = "ay0"
},
new SimpleEntity {
Name = "13", Data = "bx0"
},
new SimpleEntity {
Name = "14", Data = "by0"
},
};
var entityRepos = new GenericFilterRepository(items);
var genericRepos = NewRepos(entityRepos);
Expression <Func <SimpleEntity, bool> > expressionFilter = item => item.Data.Contains("y");
var propertyFilter = new FilterCriteria {
Property = "Data", Operation = "Contains", Value = "a"
};
var genericFilter = new[] { propertyFilter, new FilterCriteria {
Filter = expressionFilter.GetType().AssemblyQualifiedName, Value = expressionFilter
} };
Assert.AreEqual("IQ: 2, 12", TypeAndNames(genericRepos.Read(genericFilter, preferQuery: true)));
}
public void ReadGenericFilter_NamedFilter()
{
var gf = new FilterCriteria[] { new FilterCriteria {
Filter = typeof(NamedFilter).FullName
} };
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("", entityRepos.Log);
var items = genericRepos.Load(gf);
Assert.AreEqual("IL", TestIListIQueryable(items));
Assert.AreEqual("LP", entityRepos.Log);
Assert.AreEqual("f1, f2", TestUtility.Dump(items));
Assert.AreEqual("LP", entityRepos.Log);
items = genericRepos.Read(gf, preferQuery: true);
Assert.AreEqual("IQ", TestIListIQueryable(items));
Assert.AreEqual("LP, Q, QF", entityRepos.Log);
Assert.AreEqual("b1, b2", TestUtility.Dump(items));
Assert.AreEqual("LP, Q, QF, X", entityRepos.Log);
}
public void FilterGenericFilter_NamedFilter()
{
var gf = new FilterCriteria[] { new FilterCriteria {
Filter = typeof(NamedFilter).FullName
} };
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("", entityRepos.Log);
var items = genericRepos.Filter(genericRepos.Query(), gf);
Assert.AreEqual("IL", TestIListIQueryable(items));
Assert.AreEqual("Q, QF, X", entityRepos.Log);
Assert.AreEqual("b1, b2", TestUtility.Dump(items));
Assert.AreEqual("Q, QF, X", entityRepos.Log);
items = genericRepos.FilterOrQuery(genericRepos.Query(), gf);
Assert.AreEqual("IQ", TestIListIQueryable(items));
Assert.AreEqual("Q, QF, X, Q, QF", entityRepos.Log);
Assert.AreEqual("b1, b2", TestUtility.Dump(items));
Assert.AreEqual("Q, QF, X, Q, QF, X", entityRepos.Log);
}
public void ReadGenericFilter_QueryVsEnum()
{
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("IQ: ql1, ql2", TypeAndNames(genericRepos.Read(new[] {
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
}
}, preferQuery: true)));
Assert.AreEqual("QP", entityRepos.Log); entityRepos._log.Clear();
// For a single filter, loader is preferred:
Assert.AreEqual("IL: ql1, ql2", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
}
})));
Assert.AreEqual("LP", entityRepos.Log); entityRepos._log.Clear();
// For multiple filters, queryable loader (QP) is preferred:
Assert.AreEqual("IL: ql1", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})));
Assert.AreEqual("QP", entityRepos.Log); entityRepos._log.Clear();
// Using given order of filters. There is no loader for property filter (expression).
Assert.AreEqual("IL: a1_qf, b1_qf", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
},
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
})));
Assert.AreEqual("Q, QF, X", entityRepos.Log); entityRepos._log.Clear();
// When only enumerable loader is available, use enumerable filter:
Assert.AreEqual("IL: lp1_ef, lp2_ef", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(LoaderParameter).FullName
},
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
})));
Assert.AreEqual("LP, EF", entityRepos.Log); entityRepos._log.Clear();
// Trying to use queryable filter (property filter) on enumerable filtered items:
Assert.AreEqual("IL: lp1_ef", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(LoaderParameter).FullName
},
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})), "This is not a required feature. Property filter (as navigable queryable filter) does not need to work (and maybe it shouldn't) on materialized lists!");
Assert.AreEqual("LP, EF", entityRepos.Log); entityRepos._log.Clear();
// Trying to use a loader after the first position in generic filter should fail.
// REMOVE THIS TEST after (if ever) automatic FilterCriteria reordering is implemented.
TestUtility.ShouldFail(() => TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
new FilterCriteria {
Filter = typeof(LoaderParameter).FullName
},
})),
"SimpleEntity", "does not implement a filter", "LoaderParameter",
"Try reordering"); // Since there is a loader implemented, reordering parameters might help.
entityRepos._log.Clear();
// Enumerable filter after enumerable loader
Assert.AreEqual("IL: lp1_ef, lp2_ef", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(LoaderParameter).FullName
},
new FilterCriteria {
Filter = typeof(EnumerableFilter).FullName
},
})));
Assert.AreEqual("LP, EF", entityRepos.Log); entityRepos._log.Clear();
// Enumerable filter without a parametrized loader (inefficient)
Assert.AreEqual("IL: a1_ef, a2_ef, b1_ef, b2_ef", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(EnumerableFilter).FullName
},
})));
Assert.AreEqual("Q, X, EF", entityRepos.Log); entityRepos._log.Clear();
// Enumerable filter on a query (inefficient)
Assert.AreEqual("IL: ql1_ef, ql2_ef", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
new FilterCriteria {
Filter = typeof(EnumerableFilter).FullName
},
})));
Assert.AreEqual("QP, EF", entityRepos.Log); entityRepos._log.Clear();
}
public void LoadGenericFilter_CombinedFilters()
{
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("IL: a1", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(ContainsFilter).FullName, Value = new ContainsFilter {
Pattern = "a"
}
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})));
Assert.AreEqual("Q, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: b1", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})));
Assert.AreEqual("Q, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: f1, f2", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
}
})), "Should use enumerable loader (instead of queryable) if only one filter is applied.");
Assert.AreEqual("LP", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: b2", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
},
new FilterCriteria {
Filter = typeof(ContainsFilter).FullName, Value = new ContainsFilter {
Pattern = "2"
}
}
})));
Assert.AreEqual("Q, QF, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: b2", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
},
new FilterCriteria {
Filter = typeof(ContainsFilter).FullName, Value = new ContainsFilter {
Pattern = "2"
}
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "2"
}
})));
Assert.AreEqual("Q, QF, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: ", TypeAndNames(genericRepos.Load(new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
},
new FilterCriteria {
Filter = typeof(ContainsFilter).FullName, Value = new ContainsFilter {
Pattern = "2"
}
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})));
Assert.AreEqual("Q, QF, QF, X", entityRepos.Log); entityRepos._log.Clear();
}
public void FilterGenericFilter_QueryVsEnum()
{
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("IQ: a1_qf, a2_qf, b1_qf, b2_qf", TypeAndNames(genericRepos.FilterOrQuery(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
}
})));
Assert.AreEqual("Q, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: a1_qf, a2_qf, b1_qf, b2_qf", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
}
})));
Assert.AreEqual("Q, QF, X", entityRepos.Log); entityRepos._log.Clear();
// Prefere queryable filter version of QueryLoaderFilter on queryable
Assert.AreEqual("IL: a1_qf, b1_qf", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})));
Assert.AreEqual("Q, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: a1_qf, b1_qf", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
},
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
})));
Assert.AreEqual("Q, QF, X", entityRepos.Log); entityRepos._log.Clear();
// Enumerable filter on queryable:
// Prefere enumerable filter version of QueryLoaderFilter on queryable
Assert.AreEqual("IL: a1_ef_ef, a2_ef_ef, b1_ef_ef, b2_ef_ef", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(EnumerableFilter).FullName
},
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
})));
Assert.AreEqual("Q, X, EF, EF", entityRepos.Log); entityRepos._log.Clear();
// Queryable filter (property filter) on enumerable filtered items:
Assert.AreEqual("IL: a1_ef_ef, b1_ef_ef", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(EnumerableFilter).FullName
},
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})));
Assert.AreEqual("Q, X, EF, EF", entityRepos.Log); entityRepos._log.Clear();
// Trying to use a loader for filtering
TestUtility.ShouldFail(() => genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(LoaderParameter).FullName
},
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
}
}),
"SimpleEntity", "does not implement a filter", "LoaderParameter");
entityRepos._log.Clear();
Assert.AreEqual("IL: a1_ef, a2_ef, b1_ef, b2_ef", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(EnumerableFilter).FullName
},
})));
Assert.AreEqual("Q, X, EF", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: a1_qf_ef, a2_qf_ef, b1_qf_ef, b2_qf_ef", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(QueryLoaderFilter).FullName
},
new FilterCriteria {
Filter = typeof(EnumerableFilter).FullName
},
})));
Assert.AreEqual("Q, QF, X, EF", entityRepos.Log); entityRepos._log.Clear();
}
public void FilterGenericFilter_CombinedFilters()
{
var entityRepos = new GenericFilterRepository();
var genericRepos = NewRepos(entityRepos);
Assert.AreEqual("IL: a1", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(ContainsFilter).FullName, Value = new ContainsFilter {
Pattern = "a"
}
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})));
Assert.AreEqual("Q, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: b1", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})));
Assert.AreEqual("Q, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: b1, b2", TypeAndNames(genericRepos.Filter(genericRepos.Query().ToList(), new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
}
})));
Assert.AreEqual("Q, X, QF", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: b2", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
},
new FilterCriteria {
Filter = typeof(ContainsFilter).FullName, Value = new ContainsFilter {
Pattern = "2"
}
}
})));
Assert.AreEqual("Q, QF, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: b2", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
},
new FilterCriteria {
Filter = typeof(ContainsFilter).FullName, Value = new ContainsFilter {
Pattern = "2"
}
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "2"
}
})));
Assert.AreEqual("Q, QF, QF, X", entityRepos.Log); entityRepos._log.Clear();
Assert.AreEqual("IL: ", TypeAndNames(genericRepos.Filter(genericRepos.Query(), new[] {
new FilterCriteria {
Filter = typeof(NamedFilter).FullName
},
new FilterCriteria {
Filter = typeof(ContainsFilter).FullName, Value = new ContainsFilter {
Pattern = "2"
}
},
new FilterCriteria {
Property = "Name", Operation = "Contains", Value = "1"
}
})));
Assert.AreEqual("Q, QF, QF, X", entityRepos.Log); entityRepos._log.Clear();
}
