ChangeAssert (AssertJ-DB - Assertions for database 1.1.1 API)

java.lang.Object
- org.assertj.db.global.AbstractElement<E>
- - org.assertj.db.api.AbstractAssert<E>
  - - org.assertj.db.api.AbstractAssertWithOrigin<E,O>
    - - org.assertj.db.api.AbstractAssertWithOriginWithChanges<ChangeAssert,ChangesAssert>
      - org.assertj.db.api.ChangeAssert

All Implemented Interfaces:

org.assertj.core.api.Descriptable<ChangeAssert>, AssertOnChangeType<ChangeAssert>, AssertOnDataType<ChangeAssert>, AssertOnModifiedColumns<ChangeAssert>, AssertOnNumberOfColumns<ChangeAssert>, AssertOnPrimaryKey<ChangeAssert>, ChangeElement, Element, Navigation, Origin, OriginWithChanges<ChangesAssert,ChangeAssert>, OriginWithColumnsAndRowsFromChange<ChangesAssert,ChangeAssert,ChangeColumnAssert,ChangeRowAssert>, ToChange<ChangeAssert>, ToChanges<ChangesAssert>, ToColumn<ChangeColumnAssert>, ToColumnFromChange<ChangeColumnAssert>, ToRowFromChange<ChangeRowAssert>
```
public class ChangeAssert
extends AbstractAssertWithOriginWithChanges<ChangeAssert,ChangesAssert>
implements ChangeElement, OriginWithColumnsAndRowsFromChange<ChangesAssert,ChangeAssert,ChangeColumnAssert,ChangeRowAssert>, AssertOnDataType<ChangeAssert>, AssertOnPrimaryKey<ChangeAssert>, AssertOnChangeType<ChangeAssert>, AssertOnModifiedColumns<ChangeAssert>, AssertOnNumberOfColumns<ChangeAssert>
```
Assertion methods for a Change.

Author:

Régis Pouiller

Field Summary
- Fields inherited from class org.assertj.db.api.AbstractAssertWithOrigin
  origin
- Fields inherited from class org.assertj.db.global.AbstractElement
  info, myself

Constructor Summary

Constructors
Constructor and Description

ChangeAssert(ChangesAssert origin, Change change)
Constructor.

Constructors
Constructor and Description
`ChangeAssert(ChangesAssert origin, Change change)` Constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ChangeColumnAssert`	`column()` Returns assertion methods on the next `Column` in the list of `Column`s.
`ChangeColumnAssert`	`column(int index)` Returns assertion methods on the `Column` at the `index` in parameter.
`ChangeColumnAssert`	`column(String columnName)` Returns assertion methods on the `Column` corresponding to the column name in parameter.
`ChangeColumnAssert`	`columnAmongTheModifiedOnes()` Returns assertion methods on the next `Column` in the list of the modified `Column`s.
`ChangeColumnAssert`	`columnAmongTheModifiedOnes(int index)` Returns assertion methods on the `Column` at the `index` in parameter among the modified `Column`s.
`ChangeColumnAssert`	`columnAmongTheModifiedOnes(String columnName)` Returns assertion methods on the `Column` corresponding to the column name in parameter among the modified `Column`s.
`ChangeAssert`	`hasModifiedColumns(Integer... indexes)` Verifies that the indexes of columns with a modification in the values between the start point and the end point is equals to the parameters.
`ChangeAssert`	`hasModifiedColumns(String... names)` Verifies that the names of columns with a modification in the values between the start point and the end point is equals to the parameters.
`ChangeAssert`	`hasNumberOfColumns(int expected)` Verifies that the number of columns is equal to the number in parameter.
`ChangeAssert`	`hasNumberOfColumnsGreaterThan(int expected)` Verifies that the number of columns is greater than the number in parameter.
`ChangeAssert`	`hasNumberOfColumnsGreaterThanOrEqualTo(int expected)` Verifies that the number of columns is greater than or equal to the number in parameter.
`ChangeAssert`	`hasNumberOfColumnsLessThan(int expected)` Verifies that the number of columns is less than the number in parameter.
`ChangeAssert`	`hasNumberOfColumnsLessThanOrEqualTo(int expected)` Verifies that the number of columns is less than or equal to the number in parameter.
`ChangeAssert`	`hasNumberOfModifiedColumns(int number)` Verifies that the number of columns with a modification in the values between the start point and the end point is equals to the number in parameter.
`ChangeAssert`	`hasNumberOfModifiedColumnsGreaterThan(int number)` Verifies that the number of columns with a modification in the values between the start point and the end point is greater than the number in parameter.
`ChangeAssert`	`hasNumberOfModifiedColumnsGreaterThanOrEqualTo(int number)` Verifies that the number of columns with a modification in the values between the start point and the end point is greater than or equal to the number in parameter.
`ChangeAssert`	`hasNumberOfModifiedColumnsLessThan(int number)` Verifies that the number of columns with a modification in the values between the start point and the end point is less than the number in parameter.
`ChangeAssert`	`hasNumberOfModifiedColumnsLessThanOrEqualTo(int number)` Verifies that the number of columns with a modification in the values between the start point and the end point is less than or equal to the number in parameter.
`ChangeAssert`	`hasPksNames(String... names)` Verifies that the columns og the primary key of the rows of the change is the same as the parameters.
`ChangeAssert`	`hasPksValues(Object... values)` Verifies that the values of the primary key of the rows of the change are the same as the parameters.
`ChangeAssert`	`isCreation()` Verifies that the type of the change is a creation.
`ChangeAssert`	`isDeletion()` Verifies that the type of the change is a deletion.
`ChangeAssert`	`isModification()` Verifies that the type of the change is a modification.
`ChangeAssert`	`isOfType(ChangeType expected)` Verifies that the type of the change is equal to the type in parameter.
`ChangeAssert`	`isOnDataType(DataType expected)` Verifies that the data type on which is the change is equal to the type in parameter.
`ChangeAssert`	`isOnRequest()` Verifies that the data type on which is the change is a request.
`ChangeAssert`	`isOnTable()` Verifies that the data type on which is the change is a table.
`ChangeAssert`	`isOnTable(String name)` Verifies that the change is on a table with the name in parameter.
`ChangesAssert`	`returnToChanges()` Returns to level of assertion methods on `Changes`.
`ChangeRowAssert`	`rowAtEndPoint()` Returns assertion methods on the `Row` at end point.
`ChangeRowAssert`	`rowAtStartPoint()` Returns assertion methods on the `Row` at start point.

Methods inherited from class org.assertj.db.api.AbstractAssertWithOrigin
returnToOrigin

Methods inherited from class org.assertj.db.global.AbstractElement
as, as, describedAs, describedAs, getInfo

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.assertj.db.navigation.ToChanges
ofAll, ofCreation, ofCreationOnTable, ofDeletion, ofDeletionOnTable, ofModification, ofModificationOnTable, onTable

Methods inherited from interface org.assertj.db.navigation.ToChange
change, change, changeOfCreation, changeOfCreation, changeOfCreationOnTable, changeOfCreationOnTable, changeOfDeletion, changeOfDeletion, changeOfDeletionOnTable, changeOfDeletionOnTable, changeOfModification, changeOfModification, changeOfModificationOnTable, changeOfModificationOnTable, changeOnTable, changeOnTable, changeOnTableWithPks

- Constructor Detail
  - ChangeAssert
```
public ChangeAssert(ChangesAssert origin,
                    Change change)
```
    Constructor.
    
    Parameters:
    
    origin - The assertion of Origin.
    
    change - The Change on which are the assertions.
- Method Detail
  - rowAtStartPoint
```
public ChangeRowAssert rowAtStartPoint()
```
    Returns assertion methods on the Row at start point.
    
    Specified by:
    
    rowAtStartPoint in interface ToRowFromChange<ChangeRowAssert>
    
    Returns:
    
    An object to make assertions on the Row at start point.
    
    See Also:
    
    rowAtStartPoint(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.rowAtStartPoint(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.rowAtStartPoint(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.rowAtStartPoint(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.rowAtStartPoint()
  - rowAtEndPoint
```
public ChangeRowAssert rowAtEndPoint()
```
    Returns assertion methods on the Row at end point.
    
    Specified by:
    
    rowAtEndPoint in interface ToRowFromChange<ChangeRowAssert>
    
    Returns:
    
    An object to make assertions on the Row at end point.
    
    See Also:
    
    rowAtEndPoint(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.rowAtEndPoint(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.rowAtEndPoint(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.rowAtEndPoint(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.rowAtEndPoint()
  - column
```
public ChangeColumnAssert column()
```
    Returns assertion methods on the next Column in the list of Columns.
    
    Specified by:
    
    column in interface ToColumn<ChangeColumnAssert>
    
    Returns:
    
    An object to make assertions on the next Column.
    
    See Also:
    
    AbstractDbAssert.column(), AbstractDbAssert.column(), AbstractAssertWithOriginWithColumnsAndRows.column(), AbstractAssertWithOriginWithColumnsAndRows.column(), AbstractAssertWithOriginWithColumnsAndRows.column(), AbstractAssertWithOriginWithColumnsAndRows.column(), column(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column()
  - column
```
public ChangeColumnAssert column(int index)
```
    Returns assertion methods on the Column at the index in parameter.
    
    Specified by:
    
    column in interface ToColumn<ChangeColumnAssert>
    
    Parameters:
    
    index - The index corresponding to the Column.
    
    Returns:
    
    An object to make assertions on the Column.
    
    See Also:
    
    AbstractDbAssert.column(int), AbstractDbAssert.column(int), AbstractAssertWithOriginWithColumnsAndRows.column(int), AbstractAssertWithOriginWithColumnsAndRows.column(int), AbstractAssertWithOriginWithColumnsAndRows.column(int), AbstractAssertWithOriginWithColumnsAndRows.column(int), column(int), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(int), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(int), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(int), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(int)
  - column
```
public ChangeColumnAssert column(String columnName)
```
    Returns assertion methods on the Column corresponding to the column name in parameter.
    
    Specified by:
    
    column in interface ToColumn<ChangeColumnAssert>
    
    Parameters:
    
    columnName - The column name.
    
    Returns:
    
    An object to make assertions on the Column.
    
    See Also:
    
    AbstractDbAssert.column(String), AbstractDbAssert.column(String), AbstractAssertWithOriginWithColumnsAndRows.column(String), AbstractAssertWithOriginWithColumnsAndRows.column(String), AbstractAssertWithOriginWithColumnsAndRows.column(String), AbstractAssertWithOriginWithColumnsAndRows.column(String), column(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.column(String)
  - columnAmongTheModifiedOnes
```
public ChangeColumnAssert columnAmongTheModifiedOnes()
```
    Returns assertion methods on the next Column in the list of the modified Columns.
    
    Specified by:
    
    columnAmongTheModifiedOnes in interface ToColumnFromChange<ChangeColumnAssert>
    
    Returns:
    
    An object to make assertions on the Column.
    
    See Also:
    
    columnAmongTheModifiedOnes(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(String)
  - columnAmongTheModifiedOnes
```
public ChangeColumnAssert columnAmongTheModifiedOnes(int index)
```
    Returns assertion methods on the Column at the index in parameter among the modified Columns.
    
    Specified by:
    
    columnAmongTheModifiedOnes in interface ToColumnFromChange<ChangeColumnAssert>
    
    Parameters:
    
    index - The index corresponding to the Column among the list of modified Columns..
    
    Returns:
    
    An object to make assertions on the Column.
    
    See Also:
    
    columnAmongTheModifiedOnes(int), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(int), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(int), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(int), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(int)
  - columnAmongTheModifiedOnes
```
public ChangeColumnAssert columnAmongTheModifiedOnes(String columnName)
```
    Returns assertion methods on the Column corresponding to the column name in parameter among the modified Columns.
    
    Specified by:
    
    columnAmongTheModifiedOnes in interface ToColumnFromChange<ChangeColumnAssert>
    
    Parameters:
    
    columnName - The column name.
    
    Returns:
    
    An object to make assertions on the Column.
    
    See Also:
    
    columnAmongTheModifiedOnes(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(String), AbstractAssertWithOriginWithColumnsAndRowsFromChange.columnAmongTheModifiedOnes(String)
  - isOnDataType
```
public ChangeAssert isOnDataType(DataType expected)
```
    Verifies that the data type on which is the change is equal to the type in parameter.
    Example where the assertion verifies that the change is on data type TABLE :
```
 
 assertThat(changes).change(1).isOnDataType(DataType.TABLE);
 
 
```
    Specified by:
    
    isOnDataType in interface AssertOnDataType<ChangeAssert>
    
    Parameters:
    
    expected - The expected type to compare to.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AssertOnDataType.isOnTable(), AssertOnDataType.isOnRequest(), isOnDataType(org.assertj.db.type.DataType)
  - isOnTable
```
public ChangeAssert isOnTable()
```
    Verifies that the data type on which is the change is a table.
    Example where the assertion verifies that the change is on data type TABLE :
```
 
 assertThat(changes).change(1).isOnTable();
 
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOnDataType(DataType.TABLE);
 
 
```
    Specified by:
    
    isOnTable in interface AssertOnDataType<ChangeAssert>
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    DataType.TABLE, isOnTable()
  - isOnRequest
```
public ChangeAssert isOnRequest()
```
    Verifies that the data type on which is the change is a request.
    Example where the assertion verifies that the change is on data type REQUEST :
```
 
 assertThat(changes).change(1).isOnRequest();
 
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOnDataType(DataType.REQUEST);
 
 
```
    Specified by:
    
    isOnRequest in interface AssertOnDataType<ChangeAssert>
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    DataType.REQUEST, isOnRequest()
  - isOnTable
```
public ChangeAssert isOnTable(String name)
```
    Verifies that the change is on a table with the name in parameter.
    Example where the assertion verifies that the change is on TABLE called movie :
```
 
 assertThat(changes).change(1).isOnTable("movie");
 
 
```
    Specified by:
    
    isOnTable in interface AssertOnDataType<ChangeAssert>
    
    Parameters:
    
    name - The name of the table on which is the change.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    isOnTable(String)
  - hasPksNames
```
public ChangeAssert hasPksNames(String... names)
```
    Verifies that the columns og the primary key of the rows of the change is the same as the parameters.
    Example where the assertion verifies that primary key is the column called id :
```
 
 assertThat(changes).change(1).hasPksNames("id");
 
 
```
    Specified by:
    
    hasPksNames in interface AssertOnPrimaryKey<ChangeAssert>
    
    Parameters:
    
    names - The names of the primary key associated with the rows of the change.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasPksNames(String...)
  - hasPksValues
```
public ChangeAssert hasPksValues(Object... values)
```
    Verifies that the values of the primary key of the rows of the change are the same as the parameters.
    Example where the assertion verifies that primary key have the value 1 :
```
 
 assertThat(changes).change(1).hasPksValues(1);
 
 
```
    Specified by:
    
    hasPksValues in interface AssertOnPrimaryKey<ChangeAssert>
    
    Parameters:
    
    values - The values of the primary key associated with the rows of the change.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasPksValues(Object...)
  - isOfType
```
public ChangeAssert isOfType(ChangeType expected)
```
    Verifies that the type of the change is equal to the type in parameter.
    Example where the assertion verifies that the change is of type CREATION :
```
 
 assertThat(changes).change(1).isOfType(ChangeType.CREATION);
 
 
```
    Specified by:
    
    isOfType in interface AssertOnChangeType<ChangeAssert>
    
    Parameters:
    
    expected - The expected type to compare to.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AssertOnChangeType.isCreation(), AssertOnChangeType.isModification(), AssertOnChangeType.isDeletion(), isOfType(org.assertj.db.type.ChangeType)
  - isCreation
```
public ChangeAssert isCreation()
```
    Verifies that the type of the change is a creation.
    Example where the assertion verifies that the change is a creation :
```
 
 assertThat(changes).change(1).isCreation();
 
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ChangeType.CREATION);
 
 
```
    Specified by:
    
    isCreation in interface AssertOnChangeType<ChangeAssert>
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ChangeType.CREATION, isCreation()
  - isModification
```
public ChangeAssert isModification()
```
    Verifies that the type of the change is a modification.
    Example where the assertion verifies that the change is a modification :
```
 
 assertThat(changes).change(1).isModification();
 
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ChangeType.MODIFICATION);
 
 
```
    Specified by:
    
    isModification in interface AssertOnChangeType<ChangeAssert>
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ChangeType.MODIFICATION, isModification()
  - isDeletion
```
public ChangeAssert isDeletion()
```
    Verifies that the type of the change is a deletion.
    Example where the assertion verifies that the change is a deletion :
```
 
 assertThat(changes).change(1).isDeletion();
 
 
```
    This assertion method is equivalent to :
```
 
 xxxxx.isOfType(ChangeType.DELETION);
 
 
```
    Specified by:
    
    isDeletion in interface AssertOnChangeType<ChangeAssert>
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    ChangeType.DELETION, isDeletion()
  - hasNumberOfModifiedColumns
```
public ChangeAssert hasNumberOfModifiedColumns(int number)
```
    Verifies that the number of columns with a modification in the values between the start point and the end point is equals to the number in parameter.
    Example where the assertion verifies that there are 3 modified columns :
```
 
 assertThat(changes).change(1).hasNumberOfModifiedColumns(3);
 
 
```
    Specified by:
    
    hasNumberOfModifiedColumns in interface AssertOnModifiedColumns<ChangeAssert>
    
    Parameters:
    
    number - The expected number of modified columns
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasNumberOfModifiedColumns(int)
  - hasNumberOfModifiedColumnsGreaterThan
```
public ChangeAssert hasNumberOfModifiedColumnsGreaterThan(int number)
```
    Verifies that the number of columns with a modification in the values between the start point and the end point is greater than the number in parameter.
    Example where the assertion verifies that there are greater than 3 modified columns :
```
 
 assertThat(changes).change(1).hasNumberOfModifiedColumnsGreaterThan(3);
 
 
```
    Specified by:
    
    hasNumberOfModifiedColumnsGreaterThan in interface AssertOnModifiedColumns<ChangeAssert>
    
    Parameters:
    
    number - The expected number of modified columns
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasNumberOfModifiedColumnsGreaterThan(int)
  - hasNumberOfModifiedColumnsLessThan
```
public ChangeAssert hasNumberOfModifiedColumnsLessThan(int number)
```
    Verifies that the number of columns with a modification in the values between the start point and the end point is less than the number in parameter.
    Example where the assertion verifies that there are less than 3 modified columns :
```
 
 assertThat(changes).change(1).hasNumberOfModifiedColumnsLessThan(3);
 
 
```
    Specified by:
    
    hasNumberOfModifiedColumnsLessThan in interface AssertOnModifiedColumns<ChangeAssert>
    
    Parameters:
    
    number - The expected number of modified columns
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasNumberOfModifiedColumnsLessThan(int)
  - hasNumberOfModifiedColumnsGreaterThanOrEqualTo
```
public ChangeAssert hasNumberOfModifiedColumnsGreaterThanOrEqualTo(int number)
```
    Verifies that the number of columns with a modification in the values between the start point and the end point is greater than or equal to the number in parameter.
    Example where the assertion verifies that there are ar least 3 modified columns :
```
 
 assertThat(changes).change(1).hasNumberOfModifiedColumnsGreaterThanOrEqualTo(3);
 
 
```
    Specified by:
    
    hasNumberOfModifiedColumnsGreaterThanOrEqualTo in interface AssertOnModifiedColumns<ChangeAssert>
    
    Parameters:
    
    number - The expected number of modified columns
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasNumberOfModifiedColumnsGreaterThanOrEqualTo(int)
  - hasNumberOfModifiedColumnsLessThanOrEqualTo
```
public ChangeAssert hasNumberOfModifiedColumnsLessThanOrEqualTo(int number)
```
    Verifies that the number of columns with a modification in the values between the start point and the end point is less than or equal to the number in parameter.
    Example where the assertion verifies that there are at most 3 modified columns :
```
 
 assertThat(changes).change(1).hasNumberOfModifiedColumnsLessThanOrEqualTo(3);
 
 
```
    Specified by:
    
    hasNumberOfModifiedColumnsLessThanOrEqualTo in interface AssertOnModifiedColumns<ChangeAssert>
    
    Parameters:
    
    number - The expected number of modified columns
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasNumberOfModifiedColumnsLessThanOrEqualTo(int)
  - hasModifiedColumns
```
public ChangeAssert hasModifiedColumns(Integer... indexes)
```
    Verifies that the indexes of columns with a modification in the values between the start point and the end point is equals to the parameters.
    Example where the assertion verifies that indexes of modified columns are 3 and 5 :
```
 
 assertThat(changes).change(1).hasModifiedColumns(3, 5);
 
 
```
    Specified by:
    
    hasModifiedColumns in interface AssertOnModifiedColumns<ChangeAssert>
    
    Parameters:
    
    indexes - Indexes of the modified columns.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasModifiedColumns(Integer...)
  - hasModifiedColumns
```
public ChangeAssert hasModifiedColumns(String... names)
```
    Verifies that the names of columns with a modification in the values between the start point and the end point is equals to the parameters.
    Example where the assertion verifies that names of modified columns are "name" and "birth" :
```
 
 assertThat(changes).change(1).hasModifiedColumns("name", "birth");
 
 
```
    Specified by:
    
    hasModifiedColumns in interface AssertOnModifiedColumns<ChangeAssert>
    
    Parameters:
    
    names - Names of the modified columns.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    hasModifiedColumns(String...)
  - hasNumberOfColumns
```
public ChangeAssert hasNumberOfColumns(int expected)
```
    Verifies that the number of columns is equal to the number in parameter.
    Example where the assertion verifies that the table has 8 columns :
```
 assertThat(table).hasNumberOfColumns(8);
 
```
    Example where the assertion verifies that the first row of the table has 8 columns :
```
 assertThat(table).row().hasNumberOfColumns(8);
 
```
    Example where the assertion verifies that the row at end point of the first change has 8 columns :
```
 assertThat(changes).change().rowAtEndPoint().hasNumberOfColumns(8);
 
```
    Specified by:
    
    hasNumberOfColumns in interface AssertOnNumberOfColumns<ChangeAssert>
    
    Parameters:
    
    expected - The number to compare to the number of columns.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfColumns(int), AbstractRowAssert.hasNumberOfColumns(int), ChangeRowAssert.hasNumberOfColumns(int)
  - hasNumberOfColumnsGreaterThan
```
public ChangeAssert hasNumberOfColumnsGreaterThan(int expected)
```
    Verifies that the number of columns is greater than the number in parameter.
    Example where the assertion verifies that the table has more than 8 columns :
```
 assertThat(table).hasNumberOfColumnsGreaterThan(8);
 
```
    Example where the assertion verifies that the first row of the table has more than 8 columns :
```
 assertThat(table).row().hasNumberOfColumnsGreaterThan(8);
 
```
    Example where the assertion verifies that the row at end point of the first change has more than 8 columns :
```
 assertThat(changes).change().rowAtEndPoint().hasNumberOfColumnsGreaterThan(8);
 
```
    Specified by:
    
    hasNumberOfColumnsGreaterThan in interface AssertOnNumberOfColumns<ChangeAssert>
    
    Parameters:
    
    expected - The number to compare to the number of columns.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfColumnsGreaterThan(int), AbstractRowAssert.hasNumberOfColumnsGreaterThan(int), ChangeRowAssert.hasNumberOfColumnsGreaterThan(int)
  - hasNumberOfColumnsLessThan
```
public ChangeAssert hasNumberOfColumnsLessThan(int expected)
```
    Verifies that the number of columns is less than the number in parameter.
    Example where the assertion verifies that the table has less than 8 columns :
```
 assertThat(table).hasNumberOfColumnsLessThan(8);
 
```
    Example where the assertion verifies that the first row of the table has less than 8 columns :
```
 assertThat(table).row().hasNumberOfColumnsLessThan(8);
 
```
    Example where the assertion verifies that the row at end point of the first change has less than 8 columns :
```
 assertThat(changes).change().rowAtEndPoint().hasNumberOfColumnsLessThan(8);
 
```
    Specified by:
    
    hasNumberOfColumnsLessThan in interface AssertOnNumberOfColumns<ChangeAssert>
    
    Parameters:
    
    expected - The number to compare to the number of columns.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfColumnsLessThan(int), AbstractRowAssert.hasNumberOfColumnsLessThan(int), ChangeRowAssert.hasNumberOfColumnsLessThan(int)
  - hasNumberOfColumnsGreaterThanOrEqualTo
```
public ChangeAssert hasNumberOfColumnsGreaterThanOrEqualTo(int expected)
```
    Verifies that the number of columns is greater than or equal to the number in parameter.
    Example where the assertion verifies that the table has at least 8 columns :
```
 assertThat(table).hasNumberOfColumnsGreaterThanOrEqualTo(8);
 
```
    Example where the assertion verifies that the first row of the table has at least 8 columns :
```
 assertThat(table).row().hasNumberOfColumnsGreaterThanOrEqualTo(8);
 
```
    Example where the assertion verifies that the row at end point of the first change has at least 8 columns :
```
 assertThat(changes).change().rowAtEndPoint().hasNumberOfColumnsGreaterThanOrEqualTo(8);
 
```
    Specified by:
    
    hasNumberOfColumnsGreaterThanOrEqualTo in interface AssertOnNumberOfColumns<ChangeAssert>
    
    Parameters:
    
    expected - The number to compare to the number of columns.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfColumnsGreaterThanOrEqualTo(int), AbstractRowAssert.hasNumberOfColumnsGreaterThanOrEqualTo(int), ChangeRowAssert.hasNumberOfColumnsGreaterThanOrEqualTo(int)
  - hasNumberOfColumnsLessThanOrEqualTo
```
public ChangeAssert hasNumberOfColumnsLessThanOrEqualTo(int expected)
```
    Verifies that the number of columns is less than or equal to the number in parameter.
    Example where the assertion verifies that the table has at most 8 columns :
```
 assertThat(table).hasNumberOfColumnsLessThanOrEqualTo(8);
 
```
    Example where the assertion verifies that the first row of the table has at most 8 columns :
```
 assertThat(table).row().hasNumberOfColumnsLessThanOrEqualTo(8);
 
```
    Example where the assertion verifies that the row at end point of the first change has at most 8 columns :
```
 assertThat(changes).change().rowAtEndPoint().hasNumberOfColumnsLessThanOrEqualTo(8);
 
```
    Specified by:
    
    hasNumberOfColumnsLessThanOrEqualTo in interface AssertOnNumberOfColumns<ChangeAssert>
    
    Parameters:
    
    expected - The number to compare to the number of columns.
    
    Returns:
    
    this assertion object.
    
    See Also:
    
    AbstractDbAssert.hasNumberOfColumnsLessThanOrEqualTo(int), AbstractRowAssert.hasNumberOfColumnsLessThanOrEqualTo(int), ChangeRowAssert.hasNumberOfColumnsLessThanOrEqualTo(int)
  - returnToChanges
```
public ChangesAssert returnToChanges()
```
    Returns to level of assertion methods on Changes.
    
    Returns:
    
    a object of assertion methods on Changes.

Class ChangeAssert

Field Summary

Fields inherited from class org.assertj.db.api.AbstractAssertWithOrigin

Fields inherited from class org.assertj.db.global.AbstractElement

Constructor Summary

Method Summary

Methods inherited from class org.assertj.db.api.AbstractAssertWithOriginWithChanges

Methods inherited from class org.assertj.db.api.AbstractAssertWithOrigin

Methods inherited from class org.assertj.db.global.AbstractElement

Methods inherited from class java.lang.Object

Methods inherited from interface org.assertj.db.navigation.ToChanges

Methods inherited from interface org.assertj.db.navigation.ToChange

Constructor Detail

ChangeAssert

Method Detail

rowAtStartPoint

rowAtEndPoint

column

column

column

columnAmongTheModifiedOnes

columnAmongTheModifiedOnes

columnAmongTheModifiedOnes

isOnDataType

isOnTable

isOnRequest

isOnTable

hasPksNames

hasPksValues

isOfType

isCreation

isModification

isDeletion

hasNumberOfModifiedColumns

hasNumberOfModifiedColumnsGreaterThan

hasNumberOfModifiedColumnsLessThan

hasNumberOfModifiedColumnsGreaterThanOrEqualTo

hasNumberOfModifiedColumnsLessThanOrEqualTo

hasModifiedColumns

hasModifiedColumns

hasNumberOfColumns

hasNumberOfColumnsGreaterThan

hasNumberOfColumnsLessThan

hasNumberOfColumnsGreaterThanOrEqualTo

hasNumberOfColumnsLessThanOrEqualTo

returnToChanges