public void ReusabilityMechanismsClear()
{
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>();
// reset fetch instructions specified using query.Fetch(..)
query.ClearFetches();
// reset group by columns specified using query.GroupBy(..)
query.ClearGroupBys();
// reset joins specified using query.Inner/Full/LeftOuter/RightOuter
query.ClearJoins();
// reset limit/take/skip specified using query.Take(..)/Skip(..)/Limit(..)
query.ClearLimit();
// reset locks specified using query.Lock(..)
query.ClearLocks();
// reset orders specified using query.OrderBy(..)/OrderByDescending(..)
query.ClearOrders();
// reset restrictions specified using query.Where(..)/And(..)/RestrictByExample(..)
query.ClearRestrictions();
// reset timeout specified using query.Timeout(..)/TimeoutAfter(..)
query.ClearTimeout();
}
public void TestPopulatesCriteriaCacheableCachRegionAndCacheModeProperly()
{
IImmediateFlowQuery <CacheableUser> query = Session.FlowQuery <CacheableUser>()
.Cacheable("Region1", CacheMode.Put);
var criteria = (CriteriaImpl) new CriteriaBuilder()
.Build <CacheableUser, CacheableUser>
(
QuerySelection.Create(query as IQueryableFlowQuery)
);
Assert.That(criteria.Cacheable, Is.True);
Assert.That(criteria.CacheRegion, Is.EqualTo("Region1"));
Type type = typeof(CriteriaImpl);
FieldInfo field = type.GetField("cacheMode", BindingFlags.Instance | BindingFlags.NonPublic);
Assert.That(field, Is.Not.Null, "FieldInfo");
object mode = field
.GetValue(criteria);
Assert.That(mode, Is.EqualTo(CacheMode.Put));
}
public void CanUpdateLockForAliasSetUsingStringByAliasSetUsingExpression()
{
UserEntity user = null;
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>()
.Lock("user").Upgrade();
var info = (IFlowQuery)query;
Assert.That(info.Locks.Count, Is.EqualTo(1));
Lock only = info.Locks.Single();
Assert.That(only.Alias, Is.EqualTo("user"));
Assert.That(only.LockMode, Is.EqualTo(LockMode.Upgrade));
query.Lock(() => user).Force();
Assert.That(info.Locks.Count, Is.EqualTo(1));
only = info.Locks.Single();
Assert.That(only.Alias, Is.EqualTo("user"));
Assert.That(only.LockMode, Is.EqualTo(LockMode.Force));
}
public void CanStreamAllUsersGivenPartialSelectionIsSpecified()
{
var stream = new DummyResultStream <UserEntity, UserDto>();
IImmediateFlowQuery <UserEntity> query = Query <UserEntity>();
PartialSelection <UserEntity, UserDto> selection = query
.PartialSelect(x => new UserDto(x.Firstname + " " + x.Lastname))
.Add(x => new UserDto
{
IsOnline = x.IsOnline,
Id = x.Id
});
Query <UserEntity>()
.Streamed()
.Select(stream, selection);
Assert.That(stream.Items.Count, Is.EqualTo(4));
foreach (UserDto item in stream.Items)
{
Assert.That(item.Id, Is.GreaterThan(0));
Assert.That(item.Fullname, Is.Not.Null);
}
Assert.That(stream.Items.Any(x => x.IsOnline));
Assert.That(stream.Items.Any(x => !x.IsOnline));
}
public virtual void TestReuseComplexSelectPlusSelectDictionary()
{
IImmediateFlowQuery <UserEntity> query = Query <UserEntity>()
.Where(x => x.IsOnline);
var complexUsers = query.Select(x => new
{
User = new UserDto(x.Firstname + " " + x.Lastname)
{
Id = x.Id,
IsOnline = x.IsOnline,
SettingId = x.Setting.Id,
Username = x.Username
},
x.LastLoggedInStamp
});
Dictionary <long, bool> userDictionary = query
.SelectDictionary(x => x.Id, x => x.IsOnline);
Assert.That(userDictionary.Count(), Is.EqualTo(3));
Assert.That(userDictionary.All(x => x.Value));
Assert.That(complexUsers.Count(), Is.EqualTo(3));
Assert.That(complexUsers.All(x => x.User != null));
Assert.That(complexUsers.All(x => x.User.IsOnline));
}
public void FlowQueryImplementorCreatesNewReferencesForUsedCollectionsWhenMorphing()
{
var query = new DummyQuery1(Session.CreateCriteria);
query.XProject(x => new UserDto
{
Fullname = x.Firstname + " " + x.Lastname,
Id = x.Id
});
Assert.That(query.Mappings, Is.Not.Null);
Assert.That(query.Mappings.Count, Is.EqualTo(2));
IImmediateFlowQuery <UserEntity> immediate = query.Immediate();
var morphable = immediate as IMorphableFlowQuery;
Assert.That(morphable, Is.Not.Null);
// ReSharper disable once PossibleNullReferenceException
Assert.That(morphable.Mappings, Is.Not.Null);
Assert.That(!ReferenceEquals(morphable.Mappings, query.Mappings));
Assert.That(!ReferenceEquals(morphable.Orders, query.Orders));
Assert.That(!ReferenceEquals(morphable.GroupBys, query.GroupBys));
Assert.That(!ReferenceEquals(morphable.Joins, query.Joins));
Assert.That(!ReferenceEquals(morphable.Locks, query.Locks));
Assert.That(!ReferenceEquals(morphable.Aliases, query.Aliases));
}
private static WrappedFilterableQuery <T, IImmediateFlowQuery <T> > CreateWrappedQuery <T>
(
IImmediateFlowQuery <T> innerQuery
)
{
return(new WrappedFilterableQuery <T, IImmediateFlowQuery <T> >(innerQuery));
}
internal DummyBuilder
(
IFlowQuery implementor,
IImmediateFlowQuery <UserEntity> query)
: base(implementor, query, JoinType.InnerJoin)
{
}
public void CanCreateStatelessImmediateFlowQuery()
{
Assert.That(() => StatelessSession.ImmediateFlowQuery <UserEntity>(), Throws.Nothing);
IImmediateFlowQuery <UserEntity> query = StatelessSession.ImmediateFlowQuery <UserEntity>();
Assert.That(query != null);
}
private static WrappedJoinBuilder <T, IImmediateFlowQuery <T> > CreateWrappedJoinBuilder <T>
(
IJoinBuilder <T, IImmediateFlowQuery <T> > innerJoinBuilder,
IImmediateFlowQuery <T> innerQuery
)
{
return(CreateWrappedJoinBuilder(innerJoinBuilder, CreateWrappedQuery(innerQuery)));
}
private static DelegatedFilterableQuery <T, TSource, IImmediateFlowQuery <TSource> > CreateDelegatedQuery <T, TSource>
(
IImmediateFlowQuery <TSource> innerQuery,
string alias
)
{
return(new DelegatedFilterableQuery <T, TSource, IImmediateFlowQuery <TSource> >(innerQuery, alias));
}
public virtual void ConstructionExample2WithAlias()
{
UserEntity alias = null;
IImmediateFlowQuery <UserEntity> query = Session.FlowQuery(() => alias);
Assert.That(query, Is.Not.Null);
}
public void CanCreateImmediateFlowQueryWithAliasAndOptions()
{
UserEntity user = null;
IImmediateFlowQuery <UserEntity> q = Session.ImmediateFlowQuery(() => user, new FlowQueryOptions());
Assert.That(q, Is.Not.Null);
}
public void CanCreateFlowQueryWithAlias()
{
UserEntity user = null;
IImmediateFlowQuery <UserEntity> q = Session.FlowQuery(() => user);
Assert.That(q, Is.Not.Null);
}
public void CanCreateFlowQueryWithOptions()
{
Assert.That(() => Session.FlowQuery <UserEntity>(new FlowQueryOptions()), Throws.Nothing);
IImmediateFlowQuery <UserEntity> query = Session.FlowQuery <UserEntity>(new FlowQueryOptions());
Assert.That(query != null);
}
public void ApplyingNullReferenceFilterOnAliasThrows()
{
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>();
Setting alias = null;
Assert.That(() => query.ApplyFilterOn(() => alias, null), Throws.InstanceOf <ArgumentNullException>());
}
public void JoinBuilderThrowsNothingWhenNeitherQueryNorImplementorIsNullAndBothAreTheSameReference()
{
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>();
var implementor = (IFlowQuery)query;
Assert.That(() => new DummyBuilder(implementor, query), Throws.Nothing);
}
public void CanSetFetchSize()
{
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>()
.FetchSize(10);
var queryable = (IQueryableFlowQuery)query;
Assert.That(queryable.FetchSizeValue, Is.EqualTo(10));
}
public void CanSetTimeoutOnQuery()
{
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>()
.Timeout(10);
var queryable = (IQueryableFlowQuery)query;
Assert.That(queryable.TimeoutValue, Is.EqualTo(10));
}
private static DelegatedJoinBuilder <T, TSource, IImmediateFlowQuery <TSource> > CreateDelegatedJoinBuilder <T, TSource>
(
IJoinBuilder <TSource, IImmediateFlowQuery <TSource> > innerJoinBuilder,
IImmediateFlowQuery <TSource> innerQuery,
string alias
)
{
return(CreateDelegatedJoinBuilder(innerJoinBuilder, CreateDelegatedQuery <T, TSource>(innerQuery, alias), alias));
}
public void CanCountOnStar()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Count();
IImmediateFlowQuery <UserEntity> users = Query <UserEntity>()
.Where(x => x.Id, FqIs.EqualTo(query));
Assert.That(users.Count(), Is.EqualTo(1));
}
public virtual void ConstructionExample3WithOptions()
{
var options = new FlowQueryOptions();
options.Add(criteria => criteria.SetCacheMode(CacheMode.Refresh));
IImmediateFlowQuery <UserEntity> query = Session.FlowQuery <UserEntity>(options);
Assert.That(query, Is.Not.Null);
}
public void CanCountOnProjection()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Count(Projections.Distinct(Projections.Property("Id")));
IImmediateFlowQuery <UserEntity> users = Query <UserEntity>()
.Where(x => x.Id, FqIs.EqualTo(query));
Assert.That(users.Count(), Is.EqualTo(1));
}
public void SpecifyingSameFetchTwiceThrowsNothing()
{
CustomerGroupLinkEntity cl = null;
IImmediateFlowQuery <UserGroupLinkEntity> stuff = Query <UserGroupLinkEntity>()
.Fetch(x => x.Group.Customers, () => cl).Eagerly()
.Fetch(x => x.Group.Customers, () => cl).Eagerly();
Assert.That(stuff, Is.Not.Null);
}
public void CanMorphImmediateToDelayed()
{
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>();
Assert.That(query, Is.Not.Null);
IDelayedFlowQuery <UserEntity> morphed = query
.Delayed();
Assert.That(morphed, Is.Not.Null);
}
public void CanSetComment()
{
const string Comment = "Should fetch all users";
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>()
.Comment(Comment);
var queryable = (IQueryableFlowQuery)query;
Assert.That(queryable.CommentValue, Is.EqualTo(Comment));
}
public void ApplyingNullReferenceAliasOnAliasThrows()
{
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>();
Assert
.That
(
() => query.ApplyFilterOn(null, Where.Id_Of_Setting_Is(1)),
Throws.InstanceOf <ArgumentNullException>()
);
}
public void CanCountDistinctOnPropertyUsingString()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Distinct()
.Count("Id");
IImmediateFlowQuery <UserEntity> users = Query <UserEntity>()
.Where(x => x.Id, FqIs.EqualTo(query));
Assert.That(users.Count(), Is.EqualTo(1));
}
public virtual void ConstructionExample4WithAliasAndOptions()
{
UserEntity alias = null;
var options = new FlowQueryOptions();
options.Add(criteria => criteria.SetCacheMode(CacheMode.Refresh));
IImmediateFlowQuery <UserEntity> query = Session.FlowQuery(() => alias, options);
Assert.That(query, Is.Not.Null);
}
public void CanSpecifyReadOnlyTrue()
{
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>();
var queryable = (IQueryableFlowQuery)query;
Assert.That(queryable.IsReadOnly, Is.Null);
query.ReadOnly();
Assert.That(queryable.IsReadOnly, Is.True);
}
