/** * @deprecated do not use DBUnit */ @Deprecated public void assertDbUnitTable(Class testClass, String filename, String table, String... columns) { IDatabaseConnection connection = dbUnitConnection(); try { IDataSet dataSet = connection.createDataSet(); String path = "/" + testClass.getName().replace('.', '/') + "/" + filename; IDataSet expectedDataSet = dbUnitDataSet(testClass.getResourceAsStream(path)); ITable filteredTable = DefaultColumnFilter.includedColumnsTable(dataSet.getTable(table), columns); ITable filteredExpectedTable = DefaultColumnFilter.includedColumnsTable(expectedDataSet.getTable(table), columns); Assertion.assertEquals(filteredExpectedTable, filteredTable); } catch (DatabaseUnitException e) { fail(e.getMessage()); } catch (SQLException e) { throw translateException("Error while checking results", e); } finally { closeQuietly(connection); } }
public void assertEquals(IDataSet expectedDataSet, IDataSet actualDataSet, List<IColumnFilter> columnFilters) throws DatabaseUnitException { for (String tableName : expectedDataSet.getTableNames()) { ITable expectedTable = expectedDataSet.getTable(tableName); ITable actualTable = actualDataSet.getTable(tableName); assertEquals(expectedTable, actualTable, columnFilters); } }
public void assertEquals(IDataSet expectedDataSet, IDataSet actualDataSet, List<IColumnFilter> columnFilters) throws DatabaseUnitException { for (String tableName : expectedDataSet.getTableNames()) { ITable expectedTable = expectedDataSet.getTable(tableName); ITable actualTable = actualDataSet.getTable(tableName); assertEquals(expectedTable, actualTable, columnFilters); } }
DiffCollectingFailureHandler diffHandler = new DiffCollectingFailureHandler(); ITable filteredTable = DefaultColumnFilter.excludedColumnsTable(dataSet.getTable(table), excludedColumnNames); ITable filteredExpectedTable = DefaultColumnFilter.excludedColumnsTable(expectedDataSet.getTable(table), excludedColumnNames); Assertion.assertEquals(filteredExpectedTable, filteredTable, diffHandler);
private void checkDatas(TestContext testContext) throws Exception { ExpectedDataSetConfiguration expectedConfiguration = getExpectedConfiguration(testContext); if (expectedConfiguration != null) { IDataSet expectedDataSet = expectedConfiguration.getDataSet(); for (String tableName : expectedDataSet.getTableNames()) { IDataSet dataSet = dataReader.execute(testContext.getApplicationContext(), getExpectedConfiguration(testContext), tableName); String[] columnsToIgnore = expectedConfiguration.getColumnsToIgnore(); if (columnsToIgnore == null || columnsToIgnore.length == 0) { Assertion.assertEquals(expectedDataSet.getTable(tableName), dataSet.getTable(tableName)); } else { Assertion.assertEqualsIgnoreCols(expectedDataSet.getTable(tableName), dataSet.getTable(tableName), columnsToIgnore); } } } } }
public ITable getTable(String tableName) throws DataSetException { return this.innerDataSet.getTable(tableName); }
private void compare(IDataSet actualDataSet, IDataSet expectedDataSet) throws Throwable { String[] expectedTableNames = expectedDataSet.getTableNames(); if (expectedTableNames.length == 0) return; String[] actualTableNames = actualDataSet.getTableNames(); compareTableSize(actualTableNames, expectedTableNames); for (int i = 0; i < expectedTableNames.length; i++) { String tableName = expectedTableNames[i]; ITable expectedTable = expectedDataSet.getTable(tableName); String[] ignoreColumns = getIgnoreColumns(tableName); if ((ignoreColumns != null) && (ignoreColumns.length != 0)) { expectedTable = DefaultColumnFilter.excludedColumnsTable(expectedTable, ignoreColumns); } ITable actualTable = actualDataSet.getTable(tableName); Column[] expectedColumns = expectedTable.getTableMetaData().getColumns(); actualTable = DefaultColumnFilter.includedColumnsTable(actualTable, expectedColumns); Assertion.assertEquals(expectedTable, actualTable); } }
private List<String> defineColumnsForSorting(IDataSet currentDataSet, IDataSet expectedDataSet, String tableName) throws DataSetException { final List<String> columnsForSorting = new ArrayList<String>(); columnsForSorting.addAll(orderBy.global); final List<String> columsPerTable = orderBy.columnsPerTable.get(tableName); if (columsPerTable != null) { columnsForSorting.addAll(columsPerTable); } columnsForSorting.addAll(additionalColumnsForSorting(expectedDataSet.getTable(tableName), currentDataSet.getTable(tableName))); return columnsForSorting; }
public void compareContent(IDataSet currentDataSet, IDataSet expectedDataSet, AssertionErrorCollector errorCollector) throws DatabaseUnitException { final String[] tableNames = expectedDataSet.getTableNames(); final FilteredDataSet filteredCurrentDataSet = new FilteredDataSet(new IncludeTableFilter(tableNames), currentDataSet); for (String tableName : tableNames) { final List<String> columnsForSorting = defineColumnsForSorting(filteredCurrentDataSet, expectedDataSet, tableName); final ITable expectedTable = sort(new TableWrapper(expectedDataSet.getTable(tableName), filteredCurrentDataSet.getTable(tableName).getTableMetaData()), columnsForSorting); final ITable currentTable = sort(filteredCurrentDataSet.getTable(tableName), columnsForSorting); final List<String> columnsToIgnore = extractColumnsToBeIgnored(expectedDataSet.getTable(tableName), filteredCurrentDataSet.getTable(tableName)); final DiffCollectingFailureHandler diffCollector = new DiffCollectingFailureHandler(); final ITable expectedTableWithFilteredColumns = filter(expectedTable, toStringArray(columnsToIgnore)); final ITable actualTableWithFilteredColumns = filter(currentTable, toStringArray(columnsToIgnore)); Assertion.assertEquals(expectedTableWithFilteredColumns, actualTableWithFilteredColumns, diffCollector); @SuppressWarnings("unchecked") final List<Difference> diffs = diffCollector.getDiffList(); collectErrors(errorCollector, diffs); } }
private List<String> defineColumnsForSorting(IDataSet currentDataSet, IDataSet expectedDataSet, String tableName) throws DataSetException { final List<String> columnsForSorting = new ArrayList<String>(); columnsForSorting.addAll(orderBy.global); final List<String> columsPerTable = orderBy.columnsPerTable.get(tableName); if (columsPerTable != null) { columnsForSorting.addAll(columsPerTable); } columnsForSorting.addAll(additionalColumnsForSorting(expectedDataSet.getTable(tableName), currentDataSet.getTable(tableName))); return columnsForSorting; }
private List<String> defineColumnsForSorting(IDataSet currentDataSet, IDataSet expectedDataSet, String tableName) throws DataSetException { final List<String> columnsForSorting = new ArrayList<String>(); columnsForSorting.addAll(orderBy.global); final List<String> columsPerTable = orderBy.columnsPerTable.get(tableName); if (columsPerTable != null) { columnsForSorting.addAll(columsPerTable); } columnsForSorting.addAll(additionalColumnsForSorting(expectedDataSet.getTable(tableName), currentDataSet.getTable(tableName))); return columnsForSorting; }
private List<String> defineColumnsForSorting(IDataSet currentDataSet, IDataSet expectedDataSet, String tableName) throws DataSetException { final List<String> columnsForSorting = new ArrayList<String>(); columnsForSorting.addAll(orderBy.global); final List<String> columsPerTable = orderBy.columnsPerTable.get(tableName); if (columsPerTable != null) { columnsForSorting.addAll(columsPerTable); } columnsForSorting.addAll(additionalColumnsForSorting(expectedDataSet.getTable(tableName), currentDataSet.getTable(tableName))); return columnsForSorting; }
// Load expected data from an XML dataset IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File("expectedDataSet.xml")); ITable expectedTable = expectedDataSet.getTable("TABLE_NAME"); // Assert actual database table match expected table Assertion.assertEquals(expectedTable, actualTable);
public void shouldBeEmpty(IDataSet dataSet, String tableName, AssertionErrorCollector errorCollector) throws DataSetException { final SortedTable tableState = new SortedTable(dataSet.getTable(tableName)); int rowCount = tableState.getRowCount(); if (rowCount != 0) { errorCollector.collect(new AssertionError(tableName + " expected to be empty, but was <" + rowCount + ">.")); } }
public void shouldBeEmpty(IDataSet dataSet, String tableName, AssertionErrorCollector errorCollector) throws DataSetException { final SortedTable tableState = new SortedTable(dataSet.getTable(tableName)); int rowCount = tableState.getRowCount(); if (rowCount != 0) { errorCollector.collect(new AssertionError(tableName + " expected to be empty, but was <" + rowCount + ">.")); } }
public void shouldBeEmpty(IDataSet dataSet, String tableName, AssertionErrorCollector errorCollector) throws DataSetException { final SortedTable tableState = new SortedTable(dataSet.getTable(tableName)); int rowCount = tableState.getRowCount(); if (rowCount != 0) { errorCollector.collect(new AssertionError(tableName + " expected to be empty, but was <" + rowCount + ">.")); } }
public void shouldBeEmpty(IDataSet dataSet, String tableName, AssertionErrorCollector errorCollector) throws DataSetException { final SortedTable tableState = new SortedTable(dataSet.getTable(tableName)); int rowCount = tableState.getRowCount(); if (rowCount != 0) { errorCollector.collect(new AssertionError(tableName + " expected to be empty, but was <" + rowCount + ">.")); } }
@Test public void testUpdateCompany() { CompanyDao companyDao = new CompanyDao(); IDatabaseConnection dbConn = createConnection(); IDataSet dataSet = createDataSet("CompanyDataSet.xml"); DatabaseOperation.CLEAN_INSERT.execute(dbConn, dataSet); companyDao.updateCompany(100, "NewName"); IDataSet actual = dbConn.createDataSet(new String[]{"company"}); ITable companyTable = actual.getTable("company"); assertEquals("NewName", companyTable.getValue(0, "company_name")); }
private ITable sort(IDataSet dataSet, String tableName, final List<String> columnsForSorting) throws DataSetException { final SortedTable sortedTable = new SortedTable(dataSet.getTable(tableName), toArray(columnsForSorting)); sortedTable.setUseComparable(true); return sortedTable; }
protected void assertDataSet(final String expectedDataSetFile, final Connection connection, final String actualTableName, final String sql) throws SQLException, DatabaseUnitException { Connection conn = connection; try { ITable actualTable = getConnection(connection).createQueryTable( actualTableName, sql); IDataSet expectedDataSet = new FlatXmlDataSetBuilder() .build(new InputStreamReader(AbstractDBUnitTest.class .getClassLoader().getResourceAsStream( expectedDataSetFile))); assertEquals(expectedDataSet.getTable(actualTableName), actualTable); } finally { if (conn != null) { conn.close(); } } }