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)); }