public void ResolveSqlTable_ResolvesJoinInfo_Multiple()
{
var memberInfo1 = typeof(Kitchen).GetProperty("Cook");
var entityExpression1 = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Kitchen));
var unresolvedJoinInfo1 = new UnresolvedJoinInfo(entityExpression1, memberInfo1, JoinCardinality.One);
var memberInfo2 = typeof(Kitchen).GetProperty("Restaurant");
var entityExpression2 = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook));
var unresolvedJoinInfo2 = new UnresolvedJoinInfo(entityExpression2, memberInfo2, JoinCardinality.One);
var join1 = _sqlTable.GetOrAddLeftJoin(unresolvedJoinInfo1, memberInfo1);
var join2 = _sqlTable.GetOrAddLeftJoin(unresolvedJoinInfo2, memberInfo2);
var fakeResolvedJoinInfo1 = SqlStatementModelObjectMother.CreateResolvedJoinInfo(typeof(Cook));
var fakeResolvedJoinInfo2 = SqlStatementModelObjectMother.CreateResolvedJoinInfo(typeof(Restaurant));
using (_stageMock.GetMockRepository().Ordered())
{
_stageMock
.Expect(mock => mock.ResolveTableInfo(_unresolvedTableInfo, _mappingResolutionContext))
.Return(_fakeResolvedSimpleTableInfo);
_stageMock
.Expect(mock => mock.ResolveJoinInfo(join1.JoinInfo, _mappingResolutionContext))
.Return(fakeResolvedJoinInfo1);
_stageMock
.Expect(mock => mock.ResolveJoinInfo(join2.JoinInfo, _mappingResolutionContext))
.Return(fakeResolvedJoinInfo2);
}
_stageMock.Replay();
_visitor.ResolveSqlTable(_sqlTable);
_stageMock.VerifyAllExpectations();
Assert.That(join1.JoinInfo, Is.SameAs(fakeResolvedJoinInfo1));
Assert.That(join2.JoinInfo, Is.SameAs(fakeResolvedJoinInfo2));
}
public void ResolveJoinInfo_ResolvesCollectionJoinInfo()
{
var memberInfo = typeof(Cook).GetProperty("IllnessDays");
var unresolvedCollectionJoinInfo = new UnresolvedCollectionJoinInfo(Expression.Constant(new Cook()), memberInfo);
var sqlEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook));
var fakeResolvedJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
_stageMock
.Expect(mock => mock.ResolveCollectionSourceExpression(unresolvedCollectionJoinInfo.SourceExpression, _mappingResolutionContext))
.Return(sqlEntityExpression);
_resolverMock
.Expect(
mock =>
mock.ResolveJoinInfo(
Arg <UnresolvedJoinInfo> .Matches(a => a.MemberInfo == memberInfo && a.OriginatingEntity.Type == typeof(Cook)),
Arg.Is(_generator)))
.Return(fakeResolvedJoinInfo);
_stageMock
.Expect(mock => mock.ResolveTableInfo(fakeResolvedJoinInfo.ForeignTableInfo, _mappingResolutionContext))
.Return(fakeResolvedJoinInfo.ForeignTableInfo);
_stageMock
.Expect(mock => mock.ResolveJoinCondition(fakeResolvedJoinInfo.JoinCondition, _mappingResolutionContext))
.Return(fakeResolvedJoinInfo.JoinCondition);
var resolvedJoinInfo = ResolvingJoinInfoVisitor.ResolveJoinInfo(unresolvedCollectionJoinInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext);
Assert.That(resolvedJoinInfo, Is.SameAs(fakeResolvedJoinInfo));
_stageMock.VerifyAllExpectations();
_resolverMock.VerifyAllExpectations();
}
public void GetResolvedJoinInfo()
{
var joinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
var result = joinInfo.GetResolvedJoinInfo().ForeignTableInfo;
Assert.That(result, Is.SameAs(joinInfo.ForeignTableInfo));
}
public void ApplyContext_VisitResolvedJoinInfo_SameForeignTableInfo()
{
var resolvedJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
_stageMock
.Expect(mock => mock.ApplyContext(resolvedJoinInfo.ForeignTableInfo, SqlExpressionContext.ValueRequired, _mappingResolutionContext))
.Return(resolvedJoinInfo.ForeignTableInfo);
_stageMock.Replay();
var result = SqlContextJoinInfoVisitor.ApplyContext(resolvedJoinInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(resolvedJoinInfo));
}
public void ResolveTableInfo_SqlJoinedTable()
{
var joinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
var sqlJoinedTable = new SqlJoinedTable(joinInfo, JoinSemantics.Left);
_stageMock
.Expect(mock => mock.ResolveJoinInfo(joinInfo, _mappingResolutionContext))
.Return(joinInfo);
_resolverMock.Replay();
var result = ResolvingTableInfoVisitor.ResolveTableInfo(sqlJoinedTable, _resolverMock, _generator, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(joinInfo.ForeignTableInfo));
}
public void ApplyContext_SqlJoinedTable_SameJoinInfo()
{
var joinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
var sqlJoinedTable = new SqlJoinedTable(joinInfo, JoinSemantics.Left);
_stageMock
.Expect(mock => mock.ApplyContext(joinInfo, SqlExpressionContext.ValueRequired, _mappingresolutionContext))
.Return(joinInfo);
_stageMock.Replay();
var result = SqlContextTableInfoVisitor.ApplyContext(sqlJoinedTable, SqlExpressionContext.ValueRequired, _stageMock, _mappingresolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(sqlJoinedTable));
}
public void ResolveJoinedTable()
{
var joinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var joinedTable = new SqlJoinedTable(joinInfo, JoinSemantics.Left);
var fakeJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
_stageMock
.Expect(mock => mock.ResolveJoinInfo(joinInfo, _mappingResolutionContext))
.Return(fakeJoinInfo);
_stageMock.Replay();
_visitor.ResolveJoinedTable(joinedTable);
Assert.That(joinedTable.JoinInfo, Is.SameAs(fakeJoinInfo));
}
public void ApplyContext_VisitResolvedJoinInfo_NewForeignTableInfo()
{
var resolvedJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
var fakeTableInfo = new ResolvedSimpleTableInfo(typeof(Restaurant), "RestaurantTable", "r");
_stageMock
.Expect(mock => mock.ApplyContext(resolvedJoinInfo.ForeignTableInfo, SqlExpressionContext.ValueRequired, _mappingResolutionContext))
.Return(fakeTableInfo);
_stageMock.Replay();
var result = SqlContextJoinInfoVisitor.ApplyContext(resolvedJoinInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(((ResolvedJoinInfo)result).ForeignTableInfo, Is.SameAs(fakeTableInfo));
Assert.That(((ResolvedJoinInfo)result).JoinCondition, Is.SameAs(resolvedJoinInfo.JoinCondition));
}
public void ResolveJoinInfo()
{
var joinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var fakeResolvedJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo(typeof(Cook));
_resolverMock
.Expect(mock => mock.ResolveJoinInfo(joinInfo, _uniqueIdentifierGenerator))
.Return(fakeResolvedJoinInfo);
_resolverMock.Replay();
var result = _stage.ResolveJoinInfo(joinInfo, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResolvedJoinInfo));
}
public void ResolveJoinInfo_WithResolvedJoinInfo_ReresolvesTableInfo_AndKeys()
{
var resolvedJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
var fakeResolvedTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo();
_stageMock
.Expect(mock => mock.ResolveTableInfo(resolvedJoinInfo.ForeignTableInfo, _mappingResolutionContext))
.Return(fakeResolvedTableInfo);
var fakeResolvedJoinCondition = ExpressionHelper.CreateExpression(typeof(bool));
_stageMock
.Expect(mock => mock.ResolveJoinCondition(resolvedJoinInfo.JoinCondition, _mappingResolutionContext))
.Return(fakeResolvedJoinCondition);
var result = ResolvingJoinInfoVisitor.ResolveJoinInfo(resolvedJoinInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result.ForeignTableInfo, Is.SameAs(fakeResolvedTableInfo));
Assert.That(result.JoinCondition, Is.SameAs(fakeResolvedJoinCondition));
}
public void ResolveEntityRefMemberExpression()
{
var kitchenCookMember = typeof(Kitchen).GetProperty("Cook");
var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Kitchen));
var entityRefMemberExpression = new SqlEntityRefMemberExpression(entityExpression, kitchenCookMember);
var unresolvedJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var fakeJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo(typeof(Cook));
_mappingResolutionContext.AddSqlEntityMapping(entityExpression, SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)));
var fakeEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook));
_resolverMock
.Expect(
mock =>
mock.ResolveJoinInfo(
Arg <UnresolvedJoinInfo> .Matches(joinInfo => joinInfo.MemberInfo == kitchenCookMember), Arg <UniqueIdentifierGenerator> .Is.Anything))
.Return(fakeJoinInfo);
_resolverMock
.Expect(
mock =>
mock.ResolveSimpleTableInfo(
Arg <IResolvedTableInfo> .Is.Anything,
Arg <UniqueIdentifierGenerator> .Is.Anything))
.Return(fakeEntityExpression);
var result = _stage.ResolveEntityRefMemberExpression(entityRefMemberExpression, unresolvedJoinInfo, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeEntityExpression));
var sqlTable = _mappingResolutionContext.GetSqlTableForEntityExpression(entityRefMemberExpression.OriginatingEntity);
Assert.That(sqlTable.GetJoin(kitchenCookMember), Is.Not.Null);
Assert.That(sqlTable.GetJoin(kitchenCookMember).JoinInfo, Is.SameAs(fakeJoinInfo));
}