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