public void AllCreatesASelectAllQueryExecutesAndReturnsResults()
{
var mockSqlDialect = new Mock<ISqlDialect>();
mockSqlDialect.Setup(x => x.SqlCharacters).Returns(SqlCharacters.Empty);
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue<bool>(new[] { true, false }).Dequeue);
mockReader.As<IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customers = session.Include.All<Customer>();
session.ExecutePendingQueries();
Assert.Equal(1, customers.Values.Count);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public WhenExecutingMultipleQueriesAndTheSqlDialectUsedDoesNotSupportBatching()
{
var mockSqlDialect = new Mock <ISqlDialect>();
mockSqlDialect.Setup(x => x.BuildSelectSqlQuery(It.IsNotNull <IObjectInfo>(), It.IsNotNull <object>())).Returns(new SqlQuery(""));
mockCommand.Setup(x => x.ExecuteReader(It.IsAny <CommandBehavior>())).Returns(() =>
{
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue <bool>(new[] { true, false }).Dequeue);
return(mockReader.Object);
});
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
mockDbDriver.Setup(x => x.CreateConnection()).Returns(new MockDbConnectionWrapper(mockConnection.Object));
mockDbDriver.Setup(x => x.SupportsBatchedQueries).Returns(false);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var includeCustomer = session.Include.Single <Customer>(2);
var customer = session.SingleAsync <Customer>(1).Result;
}
internal static IReadOnlyWebSocketMessage Convert(Spi.Entities.WebSocket.IReadOnlyWebSocketMessage source)
=> new ReadOnlyWebSocketMessage
{
Source = source,
HandshakeSession = ReadOnlySession.Convert(source.HandshakeSession),
Opcode = (WebSocketOpcode)source.Opcode,
};
public void SingleSqlQueryExecutesAndReturnsNull()
{
var mockSqlDialect = new Mock <ISqlDialect>();
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.Read()).Returns(false);
mockReader.As <IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock <IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock <IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock <IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customer = session.Single <Customer>(new SqlQuery(""));
Assert.Null(customer);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
}
public void SingleSqlQueryExecutesAndReturnsResult()
{
var mockSqlDialect = new Mock <ISqlDialect>();
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue <bool>(new[] { true, false }).Dequeue);
mockReader.As <IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock <IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader(It.IsAny <CommandBehavior>())).Returns(mockReader.Object);
var mockConnection = new Mock <IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock <IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(new MockDbConnectionWrapper(mockConnection.Object));
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customer = session.SingleAsync <Customer>(new SqlQuery("")).Result;
Assert.NotNull(customer);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
}
public void FetchExecutesAndReturnsResults()
{
var mockSqlDialect = new Mock <ISqlDialect>();
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue <bool>(new[] { true, false }).Dequeue);
mockReader.As <IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock <IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock <IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock <IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customers = session.Fetch <Customer>(new SqlQuery(""));
Assert.Equal(1, customers.Count);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public WhenExecutingTwoQueriesAndTheSqlDialectUsedSupportsBatching()
{
var mockSqlDialect = new Mock <ISqlDialect>();
mockSqlDialect.Setup(x => x.BuildSelectSqlQuery(It.IsNotNull <IObjectInfo>(), It.IsNotNull <object>())).Returns(new SqlQuery(""));
this.mockDbDriver.Setup(x => x.Combine(It.IsNotNull <SqlQuery>(), It.IsNotNull <SqlQuery>())).Returns(new SqlQuery(""));
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue <bool>(new[] { true, false }).Dequeue);
var mockCommand = new Mock <IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock <IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
mockDbDriver.Setup(x => x.SupportsBatchedQueries).Returns(true);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var includeCustomer = session.Include.Single <Customer>(2);
var customer = session.Single <Customer>(1);
}
public void IncludeReturnsSameSessionByDifferentInterface()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
var includeSession = session.Include;
Assert.Same(session, includeSession);
}
public void AdvancedReturnsSameSessionByDifferentInterface()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
var advancedSession = session.Advanced;
Assert.Same(session, advancedSession);
}
public void AdvancedReturnsSameSessionByDifferentInterface()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock<ISqlDialect>().Object,
new Mock<IDbDriver>().Object);
var advancedSession = session.Advanced;
Assert.Same(session, advancedSession);
}
public void FetchThrowsArgumentNullExceptionForNullSqlQuery()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
var exception = Assert.Throws <ArgumentNullException>(
() => session.FetchAsync <Customer>(null).Result);
Assert.Equal("sqlQuery", exception.ParamName);
}
public void PagedThrowsArgumentNullExceptionForNullSqlQuery()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
var exception = Assert.Throws <ArgumentNullException>(
() => session.Paged <Customer>(null, PagingOptions.ForPage(1, 25)));
Assert.Equal("sqlQuery", exception.ParamName);
}
public void AMicroLiteExceptionIsThrown()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
var exception = Assert.Throws <MicroLiteException>(
() => session.Paged <Customer>(new SqlQuery(""), PagingOptions.None));
Assert.Equal(ExceptionMessages.Session_PagingOptionsMustNotBeNone, exception.Message);
}
public void SingleSqlQueryThrowsObjectDisposedExceptionIfDisposed()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
using (session)
{
}
Assert.Throws <ObjectDisposedException>(() => session.SingleAsync <Customer>(new SqlQuery("")).Result);
}
public void PagedThrowsObjectDisposedExceptionIfDisposed()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
using (session)
{
}
Assert.Throws <ObjectDisposedException>(() => session.PagedAsync <Customer>(null, PagingOptions.ForPage(1, 25)).Result);
}
public void SingleIdentifierThrowsObjectDisposedExceptionIfDisposed()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
using (session)
{
}
Assert.Throws <ObjectDisposedException>(
() => session.Single <Customer>(1));
}
public void SingleSqlQueryThrowsArgumentNullExceptionForNullSqlQuery()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
SqlQuery sqlQuery = null;
var exception = Assert.Throws <ArgumentNullException>(
() => session.Single <Customer>(sqlQuery));
Assert.Equal("sqlQuery", exception.ParamName);
}
public void SingleIdentifierThrowsArgumentNullExceptionForNullIdentifier()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock <ISqlDialect>().Object,
new Mock <IDbDriver>().Object);
object identifier = null;
var exception = Assert.Throws <ArgumentNullException>(
() => session.Single <Customer>(identifier));
Assert.Equal("identifier", exception.ParamName);
}
public void PagedExecutesAndReturnsResultsForTenthPageWithTwentyFivePerPage()
{
var sqlQuery = new SqlQuery("SELECT * FROM TABLE");
var countQuery = new SqlQuery("SELECT COUNT(*) FROM TABLE");
var pagedQuery = new SqlQuery("SELECT * FROM (SELECT *, ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS MicroLiteRowNumber FROM Customers) AS Customers");
var combinedQuery = new SqlQuery("SELECT COUNT(*) FROM TABLE;SELECT * FROM (SELECT *, ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS MicroLiteRowNumber FROM Customers) AS Customers");
var mockSqlDialect = new Mock <ISqlDialect>();
mockSqlDialect.Setup(x => x.CountQuery(sqlQuery)).Returns(countQuery);
mockSqlDialect.Setup(x => x.PageQuery(sqlQuery, PagingOptions.ForPage(10, 25))).Returns(pagedQuery);
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.FieldCount).Returns(new Queue <int>(new[] { 1, 0 }).Dequeue);
mockReader.Setup(x => x[0]).Returns(1000); // Simulate 1000 records in the count query
mockReader.Setup(x => x.NextResult()).Returns(new Queue <bool>(new[] { true, false }).Dequeue);
mockReader.Setup(x => x.Read()).Returns(new Queue <bool>(new[] { true, false, true, false }).Dequeue);
mockReader.As <IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock <IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock <IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock <IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
mockDbDriver.Setup(x => x.SupportsBatchedQueries).Returns(true);
mockDbDriver.Setup(x => x.Combine(countQuery, pagedQuery)).Returns(combinedQuery);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var page = session.Paged <Customer>(sqlQuery, PagingOptions.ForPage(10, 25));
Assert.Equal(10, page.Page);
Assert.Equal(1, page.Results.Count);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void SessionTest()
{
var requestLineSource =
@"GET / HTTP/1.1
";
Nekoxy2.ApplicationLayer.Entities.Http.HttpRequestLine.TryParse(requestLineSource, out var line);
var requestHeaderSource =
@"Host: example.com
";
Nekoxy2.ApplicationLayer.Entities.Http.HttpHeaders.TryParse(requestHeaderSource, out var requestHeaders);
var spiRequest = new Nekoxy2.ApplicationLayer.Entities.Http.HttpRequest(line, requestHeaders, new byte[0], Nekoxy2.ApplicationLayer.Entities.Http.HttpHeaders.Empty);
var statusLineSource =
@"HTTP/1.1 200 OK
";
Nekoxy2.ApplicationLayer.Entities.Http.HttpStatusLine.TryParse(statusLineSource, out var statusLine);
var responseHeaderSource =
@"Content-Length: 8
";
Nekoxy2.ApplicationLayer.Entities.Http.HttpHeaders.TryParse(responseHeaderSource, out var responseHeaders);
var responseBodySource = "hogefuga";
var spiResponse = new Nekoxy2.ApplicationLayer.Entities.Http.HttpResponse(statusLine, responseHeaders, Encoding.ASCII.GetBytes(responseBodySource), Nekoxy2.ApplicationLayer.Entities.Http.HttpHeaders.Empty);
var spiSession = new Nekoxy2.ApplicationLayer.Entities.Http.Session(spiRequest, spiResponse);
var apiSession = ReadOnlySession.Convert(spiSession);
var apiSession2 = ReadOnlySession.Convert(spiSession);
apiSession.ToString().Is(spiSession.ToString());
apiSession.GetHashCode().Is(apiSession2.GetHashCode());
apiSession.Equals(apiSession2).IsTrue();
(apiSession is Spi.Entities.Http.IReadOnlySession).IsTrue();
(apiSession is Nekoxy2.Entities.Http.IReadOnlySession).IsTrue();
apiSession.Source.Is(spiSession);
}
public void MicroLiteExceptionsCaughtByExecutePendingQueriesShouldNotBeWrappedInAnotherMicroLiteException()
{
var mockSqlDialect = new Mock <ISqlDialect>();
var mockDbDriver = new Mock <IDbDriver>();
mockDbDriver.Setup(x => x.BuildCommand(It.IsNotNull <IDbCommand>(), It.IsNotNull <SqlQuery>())).Throws <MicroLiteException>();
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
// We need at least 1 queued query otherwise we will get an exception when doing queries.Dequeue() instead.
session.Include.Scalar <int>(new SqlQuery(""));
var exception = Assert.Throws <MicroLiteException>(() => session.ExecutePendingQueries());
Assert.IsNotType <MicroLiteException>(exception.InnerException);
}
public void IncludeScalarSqlQueryExecutesAndReturnsResult()
{
var sqlQuery = new SqlQuery("");
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.FieldCount).Returns(1);
mockReader.Setup(x => x[0]).Returns(10);
mockReader.Setup(x => x.Read()).Returns(new Queue <bool>(new[] { true, false }).Dequeue);
mockReader.As <IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock <IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
mockCommand.As <IDisposable>().Setup(x => x.Dispose());
var mockConnection = new Mock <IDbConnection>();
var mockSqlDialect = new Mock <ISqlDialect>();
var mockDbDriver = new Mock <IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
mockDbDriver.Setup(x => x.BuildCommand(sqlQuery)).Returns(mockCommand.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var includeScalar = session.Include.Scalar <int>(sqlQuery);
session.ExecutePendingQueries();
Assert.Equal(10, includeScalar.Value);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void AllCreatesASelectAllQueryExecutesAndReturnsResults()
{
var mockSqlDialect = new Mock <ISqlDialect>();
mockSqlDialect.Setup(x => x.SqlCharacters).Returns(SqlCharacters.Empty);
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue <bool>(new[] { true, false }).Dequeue);
mockReader.As <IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock <IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock <IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock <IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customers = session.Include.All <Customer>();
session.ExecutePendingQueries();
Assert.Equal(1, customers.Values.Count);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void SingleIdentifierExecutesAndReturnsResult()
{
object identifier = 100;
var mockSqlDialect = new Mock <ISqlDialect>();
mockSqlDialect.Setup(x => x.BuildSelectSqlQuery(It.IsNotNull <IObjectInfo>(), identifier)).Returns(new SqlQuery(""));
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue <bool>(new[] { true, false }).Dequeue);
mockReader.As <IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock <IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock <IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock <IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customer = session.Single <Customer>(identifier);
Assert.NotNull(customer);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void SingleIdentifierExecutesAndReturnsNull()
{
object identifier = 100;
var mockSqlDialect = new Mock <ISqlDialect>();
mockSqlDialect.Setup(x => x.BuildSelectSqlQuery(It.IsNotNull <IObjectInfo>(), identifier)).Returns(new SqlQuery(""));
var mockReader = new Mock <IDataReader>();
mockReader.Setup(x => x.Read()).Returns(false);
var mockCommand = new Mock <IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader(It.IsAny <CommandBehavior>())).Returns(mockReader.Object);
var mockConnection = new Mock <IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock <IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(new MockDbConnectionWrapper(mockConnection.Object));
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customer = session.SingleAsync <Customer>(identifier).Result;
Assert.Null(customer);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void PagedExecutesAndReturnsResultsForTenthPageWithTwentyFivePerPage()
{
var sqlQuery = new SqlQuery("SELECT * FROM TABLE");
var countQuery = new SqlQuery("SELECT COUNT(*) FROM TABLE");
var pagedQuery = new SqlQuery("SELECT * FROM (SELECT *, ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS RowNumber FROM Customers) AS Customers");
var combinedQuery = new SqlQuery("SELECT COUNT(*) FROM TABLE;SELECT * FROM (SELECT *, ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS RowNumber FROM Customers) AS Customers");
var mockSqlDialect = new Mock<ISqlDialect>();
mockSqlDialect.Setup(x => x.CountQuery(sqlQuery)).Returns(countQuery);
mockSqlDialect.Setup(x => x.PageQuery(sqlQuery, PagingOptions.ForPage(10, 25))).Returns(pagedQuery);
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.FieldCount).Returns(new Queue<int>(new[] { 1, 0 }).Dequeue);
mockReader.Setup(x => x[0]).Returns(1000); // Simulate 1000 records in the count query
mockReader.Setup(x => x.NextResult()).Returns(new Queue<bool>(new[] { true, false }).Dequeue);
mockReader.Setup(x => x.Read()).Returns(new Queue<bool>(new[] { true, false, true, false }).Dequeue);
mockReader.As<IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
mockDbDriver.Setup(x => x.SupportsBatchedQueries).Returns(true);
mockDbDriver.Setup(x => x.Combine(countQuery, pagedQuery)).Returns(combinedQuery);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var page = session.Paged<Customer>(sqlQuery, PagingOptions.ForPage(10, 25));
Assert.Equal(10, page.Page);
Assert.Equal(1, page.Results.Count);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void IncludeReturnsSameSessionByDifferentInterface()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock<ISqlDialect>().Object,
new Mock<IDbDriver>().Object);
var includeSession = session.Include;
Assert.Same(session, includeSession);
}
public void PagedThrowsArgumentNullExceptionForNullSqlQuery()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock<ISqlDialect>().Object,
new Mock<IDbDriver>().Object);
var exception = Assert.Throws<ArgumentNullException>(
() => session.Paged<Customer>(null, PagingOptions.ForPage(1, 25)));
Assert.Equal("sqlQuery", exception.ParamName);
}
public void IncludeScalarSqlQueryExecutesAndReturnsResult()
{
var mockSqlDialect = new Mock<ISqlDialect>();
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.FieldCount).Returns(1);
mockReader.Setup(x => x[0]).Returns(10);
mockReader.Setup(x => x.Read()).Returns(new Queue<bool>(new[] { true, false }).Dequeue);
mockReader.As<IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var includeScalar = session.Include.Scalar<int>(new SqlQuery(""));
session.ExecutePendingQueries();
Assert.Equal(10, includeScalar.Value);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void SingleIdentifierExecutesAndReturnsResult()
{
object identifier = 100;
var mockSqlDialect = new Mock<ISqlDialect>();
mockSqlDialect.Setup(x => x.BuildSelectSqlQuery(It.IsNotNull<IObjectInfo>(), identifier)).Returns(new SqlQuery(""));
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue<bool>(new[] { true, false }).Dequeue);
mockReader.As<IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customer = session.Single<Customer>(identifier);
Assert.NotNull(customer);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void PagedThrowsObjectDisposedExceptionIfDisposed()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock<ISqlDialect>().Object,
new Mock<IDbDriver>().Object);
using (session)
{
}
Assert.Throws<ObjectDisposedException>(
() => session.Paged<Customer>(null, PagingOptions.ForPage(1, 25)));
}
public void SingleSqlQueryExecutesAndReturnsResult()
{
var sqlQuery = new SqlQuery("");
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue<bool>(new[] { true, false }).Dequeue);
var reader = mockReader.Object;
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(reader);
mockCommand.As<IDisposable>().Setup(x => x.Dispose());
var mockConnection = new Mock<IDbConnection>();
var mockSqlDialect = new Mock<ISqlDialect>();
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.GetConnection(ConnectionScope.PerTransaction)).Returns(mockConnection.Object);
mockDbDriver.Setup(x => x.BuildCommand(sqlQuery)).Returns(mockCommand.Object);
IReadOnlySession session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customer = session.Single<Customer>(sqlQuery);
Assert.NotNull(customer);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
}
public void SingleIdentifierExecutesAndReturnsNull()
{
object identifier = 100;
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.Read()).Returns(false);
var reader = mockReader.Object;
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(reader);
mockCommand.As<IDisposable>().Setup(x => x.Dispose());
var mockConnection = new Mock<IDbConnection>();
var mockSqlDialect = new Mock<ISqlDialect>();
mockSqlDialect.Setup(x => x.BuildSelectSqlQuery(It.IsNotNull<IObjectInfo>(), identifier)).Returns(new SqlQuery(""));
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.GetConnection(ConnectionScope.PerTransaction)).Returns(mockConnection.Object);
mockDbDriver.Setup(x => x.BuildCommand(It.IsNotNull<SqlQuery>())).Returns(mockCommand.Object);
IReadOnlySession session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customer = session.Single<Customer>(identifier);
Assert.Null(customer);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void SingleIdentifierThrowsArgumentNullExceptionForNullIdentifier()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock<ISqlDialect>().Object,
new Mock<IDbDriver>().Object);
object identifier = null;
var exception = Assert.Throws<ArgumentNullException>(
() => session.Single<Customer>(identifier));
Assert.Equal("identifier", exception.ParamName);
}
public WhenExecutingMultipleQueriesAndTheSqlDialectUsedDoesNotSupportBatching()
{
var mockSqlDialect = new Mock<ISqlDialect>();
mockSqlDialect.Setup(x => x.BuildSelectSqlQuery(It.IsNotNull<IObjectInfo>(), It.IsNotNull<object>())).Returns(new SqlQuery(""));
mockDbDriver.Setup(x => x.GetConnection(ConnectionScope.PerTransaction)).Returns(new Mock<IDbConnection>().Object);
mockDbDriver.Setup(x => x.SupportsBatchedQueries).Returns(false);
mockDbDriver.Setup(x => x.BuildCommand(It.IsNotNull<SqlQuery>())).Returns(() =>
{
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(() =>
{
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue<bool>(new[] { true, false }).Dequeue);
return mockReader.Object;
});
return mockCommand.Object;
});
IReadOnlySession session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var includeCustomer = session.Include.Single<Customer>(2);
var customer = session.Single<Customer>(1);
}
public void Export(ExportConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (string.IsNullOrWhiteSpace(configuration.SourceFileNamePath))
{
throw new ArgumentNullException("SourceFileNamePath");
}
//See if the local file even exists..
Console.WriteLine("Opening Source File '{0}'...", configuration.SourceFileNamePath);
using (var sourceFileStream = File.OpenRead(configuration.SourceFileNamePath))
{
if (GLFReader.IsGLF(sourceFileStream) == false)
{
throw new InvalidOperationException("Specified source file is not a Loupe Log file (glf)");
}
var sessionCollection = new SessionCollection();
var session = sessionCollection.Add(sourceFileStream);
if (session == null)
{
throw new InvalidOperationException("Unable to find session data in source data file");
}
Console.WriteLine("Initializing {0} Export...", configuration.LogMessageFormat);
using (session)
{
//instance the correct exporter...
LogMessageFormatter messageFormatter;
switch (configuration.LogMessageFormat)
{
case LogMessageFormat.Default:
messageFormatter = new DefaultLogMessageFormatter(configuration);
break;
case LogMessageFormat.Summary:
messageFormatter = new SummaryLogMessageFormatter(configuration);
break;
case LogMessageFormat.Detailed:
messageFormatter = new DetailedLogMessageFormatter(configuration);
break;
default:
throw new ArgumentOutOfRangeException();
}
ISession readOnlySession = new ReadOnlySession(session);
var stopwatch = Stopwatch.StartNew();
Console.WriteLine("Exporting Session Data into '{0}'...", configuration.TargetFileNamePath);
messageFormatter.Export(readOnlySession);
stopwatch.Stop();
Console.WriteLine("Completed export in {0:T}.", stopwatch.Elapsed);
}
}
}
public void SingleSqlQueryThrowsArgumentNullExceptionForNullSqlQuery()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock<ISqlDialect>().Object,
new Mock<IDbDriver>().Object);
SqlQuery sqlQuery = null;
var exception = Assert.Throws<ArgumentNullException>(
() => session.Single<Customer>(sqlQuery));
Assert.Equal("sqlQuery", exception.ParamName);
}
public void SingleSqlQueryThrowsObjectDisposedExceptionIfDisposed()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock<ISqlDialect>().Object,
new Mock<IDbDriver>().Object);
using (session)
{
}
Assert.Throws<ObjectDisposedException>(
() => session.Single<Customer>(new SqlQuery("")));
}
public void AMicroLiteExceptionIsThrown()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock<ISqlDialect>().Object,
new Mock<IDbDriver>().Object);
var exception = Assert.Throws<MicroLiteException>(
() => session.Paged<Customer>(new SqlQuery(""), PagingOptions.None));
Assert.Equal(ExceptionMessages.Session_PagingOptionsMustNotBeNone, exception.Message);
}
public void MicroLiteExceptionsCaughtByExecutePendingQueriesShouldNotBeWrappedInAnotherMicroLiteException()
{
var mockSqlDialect = new Mock<ISqlDialect>();
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.BuildCommand(It.IsNotNull<IDbCommand>(), It.IsNotNull<SqlQuery>())).Throws<MicroLiteException>();
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
// We need at least 1 queued query otherwise we will get an exception when doing queries.Dequeue() instead.
session.Include.Scalar<int>(new SqlQuery(""));
var exception = Assert.Throws<MicroLiteException>(() => session.ExecutePendingQueries());
Assert.IsNotType<MicroLiteException>(exception.InnerException);
}
public WhenExecutingTwoQueriesAndTheSqlDialectUsedSupportsBatching()
{
var mockSqlDialect = new Mock<ISqlDialect>();
mockSqlDialect.Setup(x => x.BuildSelectSqlQuery(It.IsNotNull<IObjectInfo>(), It.IsNotNull<object>())).Returns(new SqlQuery(""));
this.mockDbDriver.Setup(x => x.Combine(It.IsNotNull<SqlQuery>(), It.IsNotNull<SqlQuery>())).Returns(new SqlQuery(""));
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue<bool>(new[] { true, false }).Dequeue);
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
mockDbDriver.Setup(x => x.SupportsBatchedQueries).Returns(true);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var includeCustomer = session.Include.Single<Customer>(2);
var customer = session.Single<Customer>(1);
}
public void FetchExecutesAndReturnsResults()
{
var mockSqlDialect = new Mock<ISqlDialect>();
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.Read()).Returns(new Queue<bool>(new[] { true, false }).Dequeue);
mockReader.As<IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customers = session.Fetch<Customer>(new SqlQuery(""));
Assert.Equal(1, customers.Count);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
mockSqlDialect.VerifyAll();
}
public void SingleSqlQueryExecutesAndReturnsNull()
{
var mockSqlDialect = new Mock<ISqlDialect>();
var mockReader = new Mock<IDataReader>();
mockReader.Setup(x => x.Read()).Returns(false);
mockReader.As<IDisposable>().Setup(x => x.Dispose());
var mockCommand = new Mock<IDbCommand>();
mockCommand.Setup(x => x.ExecuteReader()).Returns(mockReader.Object);
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(x => x.CreateCommand()).Returns(mockCommand.Object);
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(mockConnection.Object);
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
mockSqlDialect.Object,
mockDbDriver.Object);
var customer = session.Single<Customer>(new SqlQuery(""));
Assert.Null(customer);
mockReader.VerifyAll();
mockCommand.VerifyAll();
mockConnection.VerifyAll();
}
public void FetchThrowsObjectDisposedExceptionIfDisposed()
{
var session = new ReadOnlySession(
ConnectionScope.PerTransaction,
new Mock<ISqlDialect>().Object,
new Mock<IDbDriver>().Object);
using (session)
{
}
Assert.Throws<ObjectDisposedException>(
() => session.Fetch<Customer>(null));
}
