public void TestGetCriteriaByPathUsingAlias()
{
Person personAlias = null;
Person fatherAlias = null;
DetachedCriteria criteria =
DetachedCriteria <Person> .Create(() => personAlias)
.CreateCriteria(() => personAlias.Father, () => fatherAlias);
Assert.AreEqual("fatherAlias", criteria.GetCriteriaByPath(() => personAlias.Father).Alias);
}
public void Test_CreateWithAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias");
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias);
AssertCriteriaAreEqual(expected, actual);
}
public void TestNotUsingAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.Not(Restrictions.Gt("personAlias.Age", 5)));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add(SqlExpression.Not(() => personAlias.Age > 5));
AssertCriteriaAreEqual(expected, actual);
}
public void TestGenericInUsingAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.InG <int>("personAlias.Age", new int[] { 1, 2, 3 }));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add(SqlExpression.InG <int>(() => personAlias.Age, new int[] { 1, 2, 3 }));
AssertCriteriaAreEqual(expected, actual);
}
public void Test_BetweenUsingAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.Between("personAlias.Age", 5, 10));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add(SqlExpression.Between(() => personAlias.Age, 5, 10));
AssertCriteriaAreEqual(expected, actual);
}
public void TestInUsingAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.In("personAlias.Name", new string[] { "name1", "name2", "name3" }));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add(SqlExpression.In(() => personAlias.Name, new string[] { "name1", "name2", "name3" }));
AssertCriteriaAreEqual(expected, actual);
}
public void TestCountDistinctUsingAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.SetProjection(Projections.CountDistinct("personAlias.Age"));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.SetProjection(LambdaProjection.CountDistinct(() => personAlias.Age));
AssertCriteriaAreEqual(expected, actual);
}
public void TestAddWithAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.Eq("personAlias.Name", "test name"));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add(() => personAlias.Name == "test name");
AssertCriteriaAreEqual(expected, actual);
}
public void TestOrderUsingAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.AddOrder(Order.Desc("personAlias.Name"));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.AddOrder(() => personAlias.Name, Order.Desc);
AssertCriteriaAreEqual(expected, actual);
}
public void TestIsNullUsingAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.IsNull("personAlias.Name"));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add(SqlExpression.IsNull(() => personAlias.Name));
AssertCriteriaAreEqual(expected, actual);
}
public void Test_AliasedProperty()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.SetProjection(Projections.Property("personAlias.Age"));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.SetProjection(LambdaProjection.Property(() => personAlias.Age));
AssertCriteriaAreEqual(expected, actual);
}
public void TestCreateAliasFromAliasWithJoinType()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.CreateAlias("personAlias.Father", "fatherAlias", JoinType.LeftOuterJoin);
Person personAlias = null;
Person fatherAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.CreateAlias(() => personAlias.Father, () => fatherAlias, JoinType.LeftOuterJoin);
AssertCriteriaAreEqual(expected, actual);
}
public void TestCreateCriteriaAliasAssociationWithJoinType()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.CreateCriteria("personAlias.Children", JoinType.LeftOuterJoin)
.Add(Restrictions.Eq("Nickname", "test"));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.CreateCriteria(() => personAlias.Children, JoinType.LeftOuterJoin)
.Add <Child>(c => c.Nickname == "test");
AssertCriteriaAreEqual(expected, actual);
}
public void TestLikeUsingAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.Like("personAlias.Name", "%test%"))
.Add(Restrictions.Like("personAlias.Name", "test", MatchMode.Anywhere))
.Add(Restrictions.Like("personAlias.Name", "test", MatchMode.Anywhere, '?'));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add(SqlExpression.Like(() => personAlias.Name, "%test%"))
.Add(SqlExpression.Like(() => personAlias.Name, "test", MatchMode.Anywhere))
.Add(SqlExpression.Like(() => personAlias.Name, "test", MatchMode.Anywhere, '?'));
AssertCriteriaAreEqual(expected, actual);
}
public void TestConjunctionUsingAlias()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.Conjunction()
.Add(Restrictions.Eq("personAlias.Name", "test"))
.Add(Restrictions.Gt("personAlias.Age", 5)));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add(Restrictions.Conjunction()
.Add(() => personAlias.Name == "test")
.Add(() => personAlias.Age > 5));
AssertCriteriaAreEqual(expected, actual);
}
public void TestBooleanExpression()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.Eq("IsParent", true))
.Add(Restrictions.Eq("IsParent", false))
.Add(Restrictions.Eq("personAlias.IsParent", true))
.Add(Restrictions.Eq("personAlias.IsParent", false));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add <Person>(p => p.IsParent)
.Add <Person>(p => !p.IsParent)
.Add(() => personAlias.IsParent)
.Add(() => !personAlias.IsParent);
AssertCriteriaAreEqual(expected, actual);
}
public void TestInsensitiveLike()
{
DetachedCriteria expected =
DetachedCriteria.For <Person>("personAlias")
.Add(Restrictions.InsensitiveLike("Name", "test"))
.Add(Restrictions.InsensitiveLike("Name", "tEsT", MatchMode.Anywhere))
.Add(Restrictions.InsensitiveLike("personAlias.Name", "test"))
.Add(Restrictions.InsensitiveLike("personAlias.Name", "tEsT", MatchMode.Anywhere));
Person personAlias = null;
DetachedCriteria actual =
DetachedCriteria <Person> .Create(() => personAlias)
.Add(SqlExpression.InsensitiveLike <Person>(p => p.Name, "test"))
.Add(SqlExpression.InsensitiveLike <Person>(p => p.Name, "tEsT", MatchMode.Anywhere))
.Add(SqlExpression.InsensitiveLike(() => personAlias.Name, "test"))
.Add(SqlExpression.InsensitiveLike(() => personAlias.Name, "tEsT", MatchMode.Anywhere));
AssertCriteriaAreEqual(expected, actual);
}
