public async Task Initialize_is_idempotent(bool async)
{
var reader = new FakeDbDataReader(new[] { "name" }, new[] { new[] { new object() } });
var columns = new ReaderColumn[] { new ReaderColumn <object>(true, null, (r, _) => r.GetValue(0)) };
var bufferedReader = new BufferedDataReader(reader);
Assert.False(reader.IsClosed);
if (async)
{
await bufferedReader.InitializeAsync(columns, CancellationToken.None);
}
else
{
bufferedReader.Initialize(columns);
}
Assert.True(reader.IsClosed);
if (async)
{
await bufferedReader.InitializeAsync(columns, CancellationToken.None);
}
else
{
bufferedReader.Initialize(columns);
}
}
private async Task Verify_method_result <T>(
Func <BufferedDataReader, T> method, bool async, T expectedResult,
params object[][] dataReaderContents)
{
var reader = new FakeDbDataReader(new[] { "name" }, dataReaderContents);
var columnType = typeof(T);
if (!columnType.IsValueType)
{
columnType = typeof(object);
}
var columns = new[]
{
ReaderColumn.Create(columnType, true, null, (Func <DbDataReader, int[], T>)((r, _) => r.GetFieldValue <T>(0)))
};
var bufferedReader = new BufferedDataReader(reader);
if (async)
{
await bufferedReader.InitializeAsync(columns, CancellationToken.None);
Assert.True(await bufferedReader.ReadAsync());
}
else
{
bufferedReader.Initialize(columns);
Assert.True(bufferedReader.Read());
}
Assert.Equal(expectedResult, method(bufferedReader));
}
public async Task Can_ExecuteReaderAsync(bool manageConnection)
{
var executeReaderCount = 0;
var disposeCount = -1;
var dbDataReader = new FakeDbDataReader();
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeReaderAsync: (c, b, ct) =>
{
executeReaderCount++;
disposeCount = c.DisposeCount;
return(Task.FromResult <DbDataReader>(dbDataReader));
}));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var fakeConnection = new FakeRelationalConnection(options);
var relationalCommand = new RelationalCommand(
new FakeSensitiveDataLogger <RelationalCommand>(),
new DiagnosticListener("Fake"),
"ExecuteReader Command",
new RelationalParameter[0]);
var result = await relationalCommand.ExecuteReaderAsync(fakeConnection, manageConnection : manageConnection);
Assert.Same(dbDataReader, result.DbDataReader);
Assert.Equal(0, fakeDbConnection.CloseCount);
var expectedCount = manageConnection ? 1 : 0;
Assert.Equal(expectedCount, fakeDbConnection.OpenCount);
// Durring command execution
Assert.Equal(1, executeReaderCount);
Assert.Equal(0, disposeCount);
// After command execution
Assert.Equal(0, dbDataReader.DisposeCount);
Assert.Equal(0, fakeDbConnection.DbCommands[0].DisposeCount);
// After reader dispose
result.Dispose();
Assert.Equal(1, dbDataReader.DisposeCount);
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
Assert.Equal(expectedCount, fakeDbConnection.CloseCount);
}
private static FakeDbConnection SetupConnection(TestContext context)
{
var dataReader = new FakeDbDataReader(new[] { "RowsAffected" }, new List <object[]> {
new object[] { 1 }
});
var connection = new FakeDbConnection(
"A=B", new FakeCommandExecutor(
executeReader: (c, b) => dataReader,
executeReaderAsync: (c, b, ct) => Task.FromResult <DbDataReader>(dataReader)));
((FakeRelationalConnection)context.GetService <IRelationalConnection>()).UseConnection(connection);
return(connection);
}
public void Can_ExecuteReader(bool manageConnection)
{
var executeReaderCount = 0;
var disposeCount = -1;
var dbDataReader = new FakeDbDataReader();
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeReader: (c, b) =>
{
executeReaderCount++;
disposeCount = c.DisposeCount;
return(dbDataReader);
}));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var relationalCommand = CreateRelationalCommand();
var result = relationalCommand.ExecuteReader(
new FakeRelationalConnection(options),
manageConnection: manageConnection);
Assert.Same(dbDataReader, result.DbDataReader);
Assert.Equal(0, fakeDbConnection.CloseCount);
var expectedCount = manageConnection ? 1 : 0;
Assert.Equal(expectedCount, fakeDbConnection.OpenCount);
// Durring command execution
Assert.Equal(1, executeReaderCount);
Assert.Equal(0, disposeCount);
// After command execution
Assert.Equal(0, dbDataReader.DisposeCount);
Assert.Equal(0, fakeDbConnection.DbCommands[0].DisposeCount);
// After reader dispose
result.Dispose();
Assert.Equal(1, dbDataReader.DisposeCount);
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
Assert.Equal(expectedCount, fakeDbConnection.CloseCount);
}
public async Task Can_ExecuteReaderAsync()
{
var executeReaderCount = 0;
var disposeCount = -1;
var dbDataReader = new FakeDbDataReader();
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeReaderAsync: (c, b, ct) =>
{
executeReaderCount++;
disposeCount = c.DisposeCount;
return(Task.FromResult <DbDataReader>(dbDataReader));
}));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var relationalCommand = CreateRelationalCommand();
var result = await relationalCommand.ExecuteReaderAsync(
new FakeRelationalConnection(options));
Assert.Same(dbDataReader, result.DbDataReader);
Assert.Equal(0, fakeDbConnection.CloseCount);
var expectedCount = 1;
Assert.Equal(expectedCount, fakeDbConnection.OpenCount);
// Durring command execution
Assert.Equal(1, executeReaderCount);
Assert.Equal(0, disposeCount);
// After command execution
Assert.Equal(0, dbDataReader.DisposeCount);
Assert.Equal(0, fakeDbConnection.DbCommands[0].DisposeCount);
// After reader dispose
result.Dispose();
Assert.Equal(1, dbDataReader.DisposeCount);
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
Assert.Equal(expectedCount, fakeDbConnection.CloseCount);
}
public async Task Metadata_methods_return_expected_results(bool async)
{
var reader = new FakeDbDataReader(new[] { "columnName" }, new[] { new[] { new object() }, new[] { new object() } });
var columns = new ReaderColumn[] { new ReaderColumn <object>(true, null, (r, _) => r.GetValue(0)) };
var bufferedDataReader = new BufferedDataReader(reader);
if (async)
{
await bufferedDataReader.InitializeAsync(columns, CancellationToken.None);
}
else
{
bufferedDataReader.Initialize(columns);
}
Assert.Equal(1, bufferedDataReader.FieldCount);
Assert.Equal(0, bufferedDataReader.GetOrdinal("columnName"));
Assert.Equal(typeof(object).Name, bufferedDataReader.GetDataTypeName(0));
Assert.Equal(typeof(object), bufferedDataReader.GetFieldType(0));
Assert.Equal("columnName", bufferedDataReader.GetName(0));
Assert.Equal(2, bufferedDataReader.RecordsAffected);
}
public async Task Manipulation_methods_perform_expected_actions(bool async)
{
var reader = new FakeDbDataReader(
new[] { "id", "name" },
new List <IList <object[]> > {
new[] { new object[] { 1, "a" } }, new object[0][]
});
var columns = new ReaderColumn[]
{
new ReaderColumn <int>(false, null, (r, _) => r.GetInt32(0)),
new ReaderColumn <object>(true, null, (r, _) => r.GetValue(1))
};
var bufferedDataReader = new BufferedDataReader(reader);
Assert.False(bufferedDataReader.IsClosed);
if (async)
{
await bufferedDataReader.InitializeAsync(columns, CancellationToken.None);
}
else
{
bufferedDataReader.Initialize(columns);
}
Assert.False(bufferedDataReader.IsClosed);
Assert.True(bufferedDataReader.HasRows);
if (async)
{
Assert.True(await bufferedDataReader.ReadAsync());
Assert.False(await bufferedDataReader.ReadAsync());
}
else
{
Assert.True(bufferedDataReader.Read());
Assert.False(bufferedDataReader.Read());
}
Assert.True(bufferedDataReader.HasRows);
if (async)
{
Assert.True(await bufferedDataReader.NextResultAsync());
}
else
{
Assert.True(bufferedDataReader.NextResult());
}
Assert.False(bufferedDataReader.HasRows);
if (async)
{
Assert.False(await bufferedDataReader.ReadAsync());
Assert.False(await bufferedDataReader.NextResultAsync());
}
else
{
Assert.False(bufferedDataReader.Read());
Assert.False(bufferedDataReader.NextResult());
}
Assert.False(bufferedDataReader.IsClosed);
bufferedDataReader.Close();
Assert.True(bufferedDataReader.IsClosed);
}
public void FakeDbDataReader_Sync_should_behave()
{
FakeDbCommand cmd = new FakeDbCommand();
FakeDbDataReader rdr = new FakeDbDataReader(cmd);
List <TestTable> tables = RandomDataGenerator.CreateRandomTables(seed: 1234, tableCount: 5);
rdr.ResetAndLoadTestData(tables);
rdr.AllTables.Count.ShouldBe(5);
// The RNG is rather fickle, so don't test these. See the `RandomDataGenerator_seed_values_should_produce_expected_results` test above instead.
// rdr.AllTables[0].Rows.Count.ShouldBe( 40 );
// rdr.AllTables[1].Rows.Count.ShouldBe( 52 );
// rdr.AllTables[2].Rows.Count.ShouldBe( 79 );
// rdr.AllTables[3].Rows.Count.ShouldBe( 37 );
// rdr.AllTables[4].Rows.Count.ShouldBe( 31 );
//
rdr.AsyncMode = AsyncMode.AllowSync;
// Table 0:
{
Int32 i = 0;
while (rdr.Read())
{
i++;
}
i.ShouldBe(tables[0].Rows.Count);
}
// Table 1:
rdr.NextResult().ShouldBeTrue();
{
Int32 i = 0;
while (rdr.Read())
{
i++;
}
i.ShouldBe(tables[1].Rows.Count);
}
// Table 2:
rdr.NextResult().ShouldBeTrue();
{
Int32 i = 0;
while (rdr.Read())
{
i++;
}
i.ShouldBe(tables[2].Rows.Count);
}
// Table 3:
rdr.NextResult().ShouldBeTrue();
{
Int32 i = 0;
while (rdr.Read())
{
i++;
}
i.ShouldBe(tables[3].Rows.Count);
}
// Table 4:
rdr.NextResult().ShouldBeTrue();
{
Int32 i = 0;
while (rdr.Read())
{
i++;
}
i.ShouldBe(tables[4].Rows.Count);
}
rdr.NextResult().ShouldBeFalse();
}
public async Task FakeDbDataReader_Async_should_behave()
{
FakeDbCommand cmd = new FakeDbCommand();
FakeDbDataReader rdr = new FakeDbDataReader(cmd);
//
List <TestTable> tables = RandomDataGenerator.CreateRandomTables(seed: 1234, tableCount: 5);
rdr.ResetAndLoadTestData(tables);
rdr.AllTables.Count.ShouldBe(5);
//
rdr.AsyncMode = AsyncMode.AwaitAsync;
// Table 0:
{
Int32 i = 0;
while (await rdr.ReadAsync())
{
i++;
}
i.ShouldBe(tables[0].Rows.Count);
}
// Table 1:
(await rdr.NextResultAsync()).ShouldBeTrue();
{
Int32 i = 0;
while (await rdr.ReadAsync())
{
i++;
}
i.ShouldBe(tables[1].Rows.Count);
}
// Table 2:
(await rdr.NextResultAsync()).ShouldBeTrue();
{
Int32 i = 0;
while (await rdr.ReadAsync())
{
i++;
}
i.ShouldBe(tables[2].Rows.Count);
}
// Table 3:
(await rdr.NextResultAsync()).ShouldBeTrue();
{
Int32 i = 0;
while (await rdr.ReadAsync())
{
i++;
}
i.ShouldBe(tables[3].Rows.Count);
}
// Table 4:
(await rdr.NextResultAsync()).ShouldBeTrue();
{
Int32 i = 0;
while (await rdr.ReadAsync())
{
i++;
}
i.ShouldBe(tables[4].Rows.Count);
}
(await rdr.NextResultAsync()).ShouldBeFalse();
}
