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