public void ApplyContext_UnresolvedTableInfo () { var tableInfo = new UnresolvedTableInfo (typeof (Cook)); var result = SqlContextTableInfoVisitor.ApplyContext (tableInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingresolutionContext); Assert.That (result, Is.SameAs (tableInfo)); }
public void ResolveTableInfo() { var unresolvedTableInfo = new UnresolvedTableInfo (typeof (DataContextTestClass.Customer)); var resolvedTableInfo = (ResolvedSimpleTableInfo) _mappingResolver.ResolveTableInfo (unresolvedTableInfo, _generator); Assert.That (resolvedTableInfo.ItemType, Is.EqualTo (typeof (DataContextTestClass.Customer))); Assert.That (resolvedTableInfo.TableAlias, Is.EqualTo ("t0")); Assert.That (resolvedTableInfo.TableName, Is.EqualTo ("Customers")); }
public void SetUp () { _stageMock = MockRepository.GenerateMock<IMappingResolutionStage>(); _resolverMock = MockRepository.GenerateMock<IMappingResolver>(); _unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook)); _resolvedTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook)); _generator = new UniqueIdentifierGenerator(); _sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook)); _mappingResolutionContext = new MappingResolutionContext(); }
public void SetUp () { _stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage>(); _mappingResolutionContext = new MappingResolutionContext(); _visitor = new TestableSqlStatementResolver (_stageMock, _mappingResolutionContext); _unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook)); _sqlTable = SqlStatementModelObjectMother.CreateSqlTable (_unresolvedTableInfo); _fakeResolvedSimpleTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook)); }
public void SetUp () { _context = SqlStatementModelObjectMother.CreateSqlPreparationContext(); _source = ExpressionHelper.CreateMainFromClause<Cook>(); var source = new UnresolvedTableInfo (typeof (int)); _sqlTable = new SqlTable (source, JoinSemantics.Inner); _parentContext = SqlStatementModelObjectMother.CreateSqlPreparationContext (); _parentSource = ExpressionHelper.CreateMainFromClause<Cook>(); _parentSqlTable = new SqlTable (new UnresolvedTableInfo (typeof (int)), JoinSemantics.Inner); _sqlStatementBuilder = new SqlStatementBuilder(); _contextWithParent = new SqlPreparationContext (_parentContext, _sqlStatementBuilder); }
public void SetUp () { _resolverMock = MockRepository.GenerateMock<IMappingResolver>(); _uniqueIdentifierGenerator = new UniqueIdentifierGenerator(); _unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook)); _sqlTable = SqlStatementModelObjectMother.CreateSqlTable (_unresolvedTableInfo); _fakeResolvedSimpleTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook)); _stage = new DefaultMappingResolutionStage (_resolverMock, _uniqueIdentifierGenerator); _mappingResolutionContext = new MappingResolutionContext(); }
public virtual IResolvedTableInfo ResolveTableInfo (UnresolvedTableInfo tableInfo, UniqueIdentifierGenerator generator) { switch (tableInfo.ItemType.Name) { case "Cook": case "Knife": case "Kitchen": case "Restaurant": case "Company": return CreateResolvedTableInfo (tableInfo.ItemType, generator); case "Chef": return new ResolvedSimpleTableInfo (tableInfo.ItemType, "dbo."+tableInfo.ItemType.Name + "Table", generator.GetUniqueIdentifier ("t")); } throw new UnmappedItemException ("The type " + tableInfo.ItemType + " cannot be queried from the stub provider."); }
public static SqlTable CreateSqlTable_WithUnresolvedTableInfo (Type type) { var unresolvedTableInfo = new UnresolvedTableInfo (type); var sqlTable = new SqlTable (unresolvedTableInfo, JoinSemantics.Inner); return sqlTable; }
ITableInfo ITableInfoVisitor.VisitUnresolvedTableInfo (UnresolvedTableInfo tableInfo) { throw new InvalidOperationException ("UnresolvedTableInfo is not valid at this point."); }
public ITableInfo VisitUnresolvedTableInfo (UnresolvedTableInfo tableInfo) { ArgumentUtility.CheckNotNull ("tableInfo", tableInfo); var result = _resolver.ResolveTableInfo (tableInfo, _generator); return result.Accept (this); }
public ITableInfo VisitUnresolvedTableInfo (UnresolvedTableInfo tableInfo) { ArgumentUtility.CheckNotNull ("tableInfo", tableInfo); return tableInfo; }
public void AddQuerySource () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(); var preparedFromExpressionInfo = new FromExpressionInfo ( sqlTable, new Ordering[] { }, new SqlTableReferenceExpression (sqlTable), null); _stageMock .Expect ( mock => mock.PrepareFromExpression ( Arg.Is (_mainFromClause.FromExpression), Arg<ISqlPreparationContext>.Matches (c => c != _context), Arg<Func<ITableInfo, SqlTable>>.Is.Anything)) .Return (preparedFromExpressionInfo) .WhenCalled (mi => { var tableCreator = (Func<ITableInfo, SqlTable>) mi.Arguments[2]; var sampleTableInfo = new UnresolvedTableInfo (typeof (Cook)); var table = tableCreator (sampleTableInfo); Assert.That (table, Is.TypeOf (typeof (SqlTable))); Assert.That (((SqlTable) table).TableInfo, Is.SameAs (sampleTableInfo)); Assert.That (table.JoinSemantics, Is.EqualTo (JoinSemantics.Inner)); }); _stageMock.Replay(); var result = _visitor.AddQuerySource (_mainFromClause, _mainFromClause.FromExpression); _stageMock.VerifyAllExpectations(); Assert.That (result, Is.SameAs (sqlTable)); Assert.That (_visitor.Context.GetExpressionMapping (new QuerySourceReferenceExpression (_mainFromClause)), Is.Not.Null); }
public void SetUp () { _tableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook)); }