private static void FiddleWithPropertiesAsFakeDbDataAdapter(FakeDbDataAdapter adapter) { { FakeDbCommand cmd = (FakeDbCommand)adapter.SelectCommand; adapter.SelectCommand = null; adapter.SelectCommand = cmd; } { FakeDbCommand cmd = (FakeDbCommand)adapter.InsertCommand; adapter.InsertCommand = null; adapter.InsertCommand = cmd; } { FakeDbCommand cmd = (FakeDbCommand)adapter.DeleteCommand; adapter.DeleteCommand = null; adapter.DeleteCommand = cmd; } { FakeDbCommand cmd = (FakeDbCommand)adapter.UpdateCommand; adapter.UpdateCommand = null; adapter.UpdateCommand = cmd; } }
public void FakeDbCommandBuilder_should_work() { List <TestTable> randomDataSource = RandomDataGenerator.CreateRandomTables(seed: 1234, tableCount: 5, /*allowZeroRowsInTablesByIdx: */ 1, 3); using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { connection.Open(); using (FakeDbDataAdapter adpt = new FakeDbDataAdapter(selectCommand)) using (FakeDbCommandBuilder cmdBuilder = adpt.CreateCommandBuilder()) { cmdBuilder.DataAdapter.ShouldBe(adpt); FakeDbCommand deleteCommand1 = cmdBuilder.GetDeleteCommand(); // Same as ` useColumnsForParameterNames: false );` FakeDbCommand updateCommand1 = cmdBuilder.GetUpdateCommand(); FakeDbCommand insertCommand1 = cmdBuilder.GetInsertCommand(); FakeDbCommand deleteCommand2 = cmdBuilder.GetDeleteCommand(useColumnsForParameterNames: true); FakeDbCommand updateCommand2 = cmdBuilder.GetUpdateCommand(useColumnsForParameterNames: true); FakeDbCommand insertCommand2 = cmdBuilder.GetInsertCommand(useColumnsForParameterNames: true); _ = deleteCommand1.ShouldNotBeNull(); _ = updateCommand1.ShouldNotBeNull(); _ = insertCommand1.ShouldNotBeNull(); _ = deleteCommand2.ShouldNotBeNull(); _ = updateCommand2.ShouldNotBeNull(); _ = insertCommand2.ShouldNotBeNull(); } } }
public void FakeDbDataAdapter_properties_should_not_have_infinite_loops_and_stack_overflows() { List <TestTable> randomDataSource = RandomDataGenerator.CreateRandomTables(seed: 1, tableCount: 2, /*allowZeroRowsInTablesByIdx: */ 1, 3); // Test that .Dispose() works (DbDataAdapter clears mutable properties in its disposal method) using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) using (FakeDbDataAdapter adapter = new FakeDbDataAdapter(selectCommand)) { } using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand1 = connection.CreateCommand(testTables: randomDataSource)) using (FakeDbCommand selectCommand2 = connection.CreateCommand(testTables: randomDataSource)) using (FakeDbDataAdapter adapter = new FakeDbDataAdapter(selectCommand1)) { using (FakeProxiedDbDataAdapter prox = new FakeProxiedDbDataAdapter(selectCommand1)) { FiddleWithPropertiesAsFakeProxiedDbDataAdapter(prox); FiddleWithPropertiesAsFakeDbDataAdapter(prox); FiddleWithPropertiesAsDbDataAdapter(prox); FiddleWithPropertiesAsIDbDataAdapter(prox); } FiddleWithPropertiesAsFakeDbDataAdapter(adapter); FiddleWithPropertiesAsDbDataAdapter(adapter); FiddleWithPropertiesAsIDbDataAdapter(adapter); } }
protected TResult DoRunDbDataAdapterSynchronous(Int32 seed, Int32 tableCount) { List <TestTable> randomDataSource = RandomDataGenerator.CreateRandomTables(seed: seed, tableCount: tableCount); using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { connection.Open(); using (FakeDbDataAdapter adapter = new FakeDbDataAdapter(selectCommand)) { return(this.RunDbDataAdapterSynchronous(randomDataSource, adapter)); } } }
public async Task Proxy_FillAsync_should_work_identically_to_DbDataReader_Fill() { List <TestTable> randomDataSource = RandomDataGenerator.CreateRandomTables(seed: 1234, tableCount: 5, /*allowZeroRowsInTablesByIdx: */ 1, 3); // Part 1: Use proxy DataSet dataSetFromProxy; { using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AwaitAsync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { await connection.OpenAsync(); using (BatchingFakeProxiedDbDataAdapter adpt = new BatchingFakeProxiedDbDataAdapter(selectCommand)) { dataSetFromProxy = new DataSet(); // `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly. Int32 rowsInFirstTable = await adpt.FillAsync(dataSetFromProxy); rowsInFirstTable.ShouldBe(40); } } } // Part 2: Use real DataSet dataSetFromReal; { using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { connection.Open(); using (FakeDbDataAdapter adpt = new FakeDbDataAdapter(selectCommand)) { dataSetFromReal = new DataSet(); Int32 rowsInFirstTable = adpt.Fill(dataSetFromReal); rowsInFirstTable.ShouldBe(40); } } } // Assert equality: DataTableMethods.DataSetEquals(dataSetFromProxy, dataSetFromReal, out String diffs).ShouldBeTrue(customMessage: diffs); }
public void Proxy_FillSchema_should_work_identically_to_FillSchema_SchemaType(SchemaType schemaType) { List <TestTable> randomDataSource = RandomDataGenerator.CreateRandomTables(seed: 1234, tableCount: 5, /*allowZeroRowsInTablesByIdx: */ 1, 3); // Part 1: Use proxy DataTable[] whatIsThisFromProxy; DataSet schemaFromProxy; { using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { connection.Open(); using (BatchingFakeProxiedDbDataAdapter adpt = new BatchingFakeProxiedDbDataAdapter(selectCommand)) { schemaFromProxy = new DataSet(); whatIsThisFromProxy = adpt.FillSchema(schemaFromProxy, schemaType); } } } // Part 2: Use real DataTable[] whatIsThisFromReal; DataSet schemaFromReal; { using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { connection.Open(); using (FakeDbDataAdapter adpt = new FakeDbDataAdapter(selectCommand)) { schemaFromReal = new DataSet(); whatIsThisFromReal = adpt.FillSchema(schemaFromReal, schemaType); } } } // Assert equality: DataTableMethods.DataSetEquals(schemaFromProxy, schemaFromReal, out String diffs).ShouldBeTrue(customMessage: diffs); }
protected override DataSet RunDbDataAdapterSynchronous(List <TestTable> randomDataSource, FakeDbDataAdapter adapter) { DataSet dataSet = new DataSet(); Int32 rowsInFirstTable = adapter.Fill2(dataSet, srcTable: "Foobar"); rowsInFirstTable.ShouldBe(40); return(dataSet); }
protected override DataSet RunDbDataAdapterSynchronous(List <TestTable> randomDataSource, FakeDbDataAdapter adapter) { DataSet dataSet = new DataSet(); Int32 rowsInFirstTable = adapter.Fill3(dataSet, startRecord: 5, maxRecords: 10, srcTable: "Barqux"); rowsInFirstTable.ShouldBe(10); return(dataSet); }
// TODO: Variations of `UpdateNTest` that use custom Table/Column Mappings. // This is documented here: https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/dataadapter-datatable-and-datacolumn-mappings // This would then cover the `Table`, `Table1`, etc. naming issues. protected override U1Pair RunDbDataAdapterSynchronous(List <TestTable> randomDataSource, FakeDbDataAdapter adapter) { using (FakeDbCommandBuilder cmdBuilder = adapter.CreateCommandBuilder()) { DataSet dataSet = new DataSet(); // `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly. Int32 rowsInFirstTable = adapter.Fill(dataSet); rowsInFirstTable.ShouldBe(40); // Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataSet(dataSet); List <(String tableName, String command)> executedCommands = new List <(string tableName, string command)>(); // adapter.UpdateCommand = cmdBuilder.GetUpdateCommand(); adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => DataTableMethods.GetUpdateStatementNonQueryResultRowCountValue(expectedTableName: "TODO", adapter, dataSet, cmd, rowsModified, executedCommands); Int32 updatedRows = adapter.Update1(dataSet); // updatedRows... in first table only? // updatedRows.ShouldBe( rowsModified ); return(dataSet, rowsModified, updatedRows); } }
protected override FS1Pair RunDbDataAdapterSynchronous(List <TestTable> randomDataSource, FakeDbDataAdapter adapter) { DataSet dataSet = new DataSet(); DataTable[] schemaTables = adapter.FillSchema1(dataSet, schemaType: this.SchemaType); return(dataSet, schemaTables); }
protected override U2Pair RunDbDataAdapterSynchronous(List <TestTable> randomDataSource, FakeDbDataAdapter adapter) { using (FakeDbCommandBuilder cmdBuilder = adapter.CreateCommandBuilder()) { DataTable dataTable = new DataTable(); // `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly. Int32 rowsInFirstTable = adapter.Fill(dataTable); rowsInFirstTable.ShouldBe(40); // Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataTable(dataTable); // adapter.UpdateCommand = cmdBuilder.GetUpdateCommand(); adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => DataTableMethods.GetUpdateStatementNonQueryResultRowCountValue(expectedTableName: "TODO", adapter, dataTable, cmd, rowsModified); DataRow[] rows = dataTable.Rows.Cast <DataRow>().ToArray(); Int32 updatedRows = adapter.Update2(rows); // updatedRows.ShouldBe( rowsModified ); return(rows, rowsModified, updatedRows); } }
public void Proxy_Update_should_work_identically_to_Update() { List <TestTable> randomDataSource = RandomDataGenerator.CreateRandomTables(seed: 1234, tableCount: 5, /*allowZeroRowsInTablesByIdx: */ 1, 3); // TODO: Multiple table UPDATE support is... complicated: https://stackoverflow.com/questions/16218856/how-to-update-two-tables-with-one-dataset // Part 1: Use proxy DataSet dataSetFromProxy; { using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { connection.Open(); using (BatchingFakeProxiedDbDataAdapter adapter = new BatchingFakeProxiedDbDataAdapter(selectCommand)) using (FakeDbCommandBuilder cmdBuilder = new FakeDbCommandBuilder(adapter)) { dataSetFromProxy = new DataSet(); // `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly. Int32 rowsInFirstTable = adapter.Fill(dataSetFromProxy); rowsInFirstTable.ShouldBe(40); // Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataSet(dataSetFromProxy); // adapter.UpdateCommand = cmdBuilder.GetUpdateCommand(); adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => DataTableMethods.GetUpdateStatementNonQueryResultRowCountValue(expectedTableName: "TODO", adapter, dataSetFromProxy, cmd, rowsModified); Int32 updatedRows = adapter.Update(dataSetFromProxy); // updatedRows... in first table only? // updatedRows.ShouldBe( rowsModified ); } } } // Part 2: Use real DataSet dataSetFromReal; { using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { connection.Open(); using (FakeDbDataAdapter adapter = new FakeDbDataAdapter(selectCommand)) using (FakeDbCommandBuilder cmdBuilder = adapter.CreateCommandBuilder()) { dataSetFromReal = new DataSet(); // `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly. Int32 rowsInFirstTable = adapter.Fill(dataSetFromReal); rowsInFirstTable.ShouldBe(40); // Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataSet(dataSetFromReal); // adapter.UpdateCommand = cmdBuilder.GetUpdateCommand(); adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => DataTableMethods.GetUpdateStatementNonQueryResultRowCountValue(expectedTableName: "TODO", adapter, dataSetFromReal, cmd, rowsModified); Int32 updatedRows = adapter.Update(dataSetFromReal); // updatedRows... in first table only? // updatedRows.ShouldBe( rowsModified ); } } } // Assert equality: DataTableMethods.DataSetEquals(dataSetFromProxy, dataSetFromReal, out String diffs).ShouldBeTrue(customMessage: diffs); }
public async Task Proxy_UpdateAsync_should_work_identically_to_Update() { List <TestTable> randomDataSource = RandomDataGenerator.CreateRandomTables(seed: 1234, tableCount: 5, /*allowZeroRowsInTablesByIdx: */ 1, 3); // Part 1: Use proxy DataSet dataSetFromProxy; { using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AwaitAsync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { await connection.OpenAsync(); using (BatchingFakeProxiedDbDataAdapter adapter = new BatchingFakeProxiedDbDataAdapter(selectCommand)) using (DbCommandBuilder cmdBuilder = await adapter.CreateCommandBuilderAsync().ConfigureAwait(false)) { dataSetFromProxy = new DataSet(); // `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly. Int32 rowsInFirstTable = await adapter.FillAsync(dataSetFromProxy); rowsInFirstTable.ShouldBe(40); // Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataSet(dataSetFromProxy); // adapter.UpdateCommand = (FakeDbCommand)cmdBuilder.GetUpdateCommand(); adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => 1; // HACK /* DataTableMethods.GetNonQueryResultRowCountValue( dataSetFromProxy, cmd, rowsModified ); */; // Int32 updatedRows = await adapter.UpdateAsync(dataSetFromProxy); // updatedRows... in first table only? // updatedRows.ShouldBe( rowsModified ); } } } // Part 2: Use real DataSet dataSetFromReal; { using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync)) using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource)) { connection.Open(); using (FakeDbDataAdapter adapter = new FakeDbDataAdapter(selectCommand)) using (FakeDbCommandBuilder cmdBuilder = adapter.CreateCommandBuilder()) { dataSetFromReal = new DataSet(); // `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly. Int32 rowsInFirstTable = adapter.Fill(dataSetFromReal); rowsInFirstTable.ShouldBe(40); // Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataSet(dataSetFromReal); // adapter.UpdateCommand = cmdBuilder.GetUpdateCommand(); adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => 1; // HACK /* DataTableMethods.GetNonQueryResultRowCountValue( dataSetFromProxy, cmd, rowsModified ); */; // Int32 updatedRows = adapter.Update(dataSetFromReal); // updatedRows... in first table only? // updatedRows.ShouldBe( rowsModified ); } } } // Assert equality: DataTableMethods.DataSetEquals(dataSetFromProxy, dataSetFromReal, out String diffs).ShouldBeTrue(customMessage: diffs); }
protected override DataTable RunDbDataAdapterSynchronous(List <TestTable> randomDataSource, FakeDbDataAdapter adapter) { DataTable dataTable = new DataTable(); Int32 rowsInFirstTable = adapter.Fill4(dataTable: dataTable); rowsInFirstTable.ShouldBe(40); return(dataTable); }
// When using Fill5 with DataTable[] arrays of length other-than 1, the startRecord and maxRecord values must both be zero. // See `throw ADP.OnlyOneTableForStartRecordOrMaxRecords();` in the reference-source. protected override DataTable[] RunDbDataAdapterSynchronous(List <TestTable> randomDataSource, FakeDbDataAdapter adapter) { DataTable[] tables = new DataTable[5] { new DataTable(tableName: "Foo", tableNamespace: "NS1"), new DataTable(tableName: "Bar", tableNamespace: "NS1"), new DataTable(tableName: "Baz", tableNamespace: "NS1"), new DataTable(tableName: "Qux", tableNamespace: "NS1"), new DataTable(tableName: "Tux", tableNamespace: "NS1") }; Int32 rowsInFirstTable = adapter.Fill5(startRecord: 0, maxRecords: 0, dataTables: tables); rowsInFirstTable.ShouldBe(40); return(tables); }
protected abstract TResult RunDbDataAdapterSynchronous(List <TestTable> randomDataSource, FakeDbDataAdapter adapter);