io.github.bekoenig.assertj.schemacrawler.api.AbstractKeyColumnAssert Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of assertj-schemacrawler Show documentation
An assertj extension for schema-crawler.
There is a newer version: 1.1.0
Show newest version
package io.github.bekoenig.assertj.schemacrawler.api;

import schemacrawler.schema.*;

import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

public abstract class AbstractKeyColumnAssert<
        SELF extends AbstractKeyColumnAssert,
        ACTUAL extends Column>
        extends AbstractDependantObjectAssert {

    protected AbstractKeyColumnAssert(ACTUAL actual, Class selfType) {
        super(actual, selfType);
    }

    public SELF satisfiesColumnDataType(Consumer requirement) {
        extracting(BaseColumn::getColumnDataType).satisfies(requirement);
        return myself;
    }

    public SELF matchesDecimalDigits(Predicate predicate) {
        extracting(BaseColumn::getDecimalDigits).matches(predicate);
        return myself;
    }

    public SELF matchesDefaultValue(Predicate predicate) {
        extracting(Column::getDefaultValue).matches(predicate);
        return myself;
    }

    public SELF matchesOrdinalPosition(Predicate predicate) {
        extracting(BaseColumn::getOrdinalPosition).matches(predicate);
        return myself;
    }

    public ListableNamedObjectAssert>, Privilege, PrivilegeAssert> privileges() {
        isNotNull();
        return new ListableNamedObjectAssert<>(
                actual.getPrivileges(),
                SchemaCrawlerAssertions::assertThat);
    }

    public SELF satisfiesReferencedColumn(Consumer requirement) {
        extracting(Column::getReferencedColumn).satisfies(requirement);
        return myself;
    }

    public SELF matchesSize(Predicate predicate) {
        extracting(BaseColumn::getSize).matches(predicate);
        return myself;
    }

    public SELF satisfiesType(Consumer requirement) {
        extracting(BaseColumn::getType).satisfies(requirement);
        return myself;
    }

    public SELF matchesWidth(Predicate predicate) {
        extracting(BaseColumn::getWidth).matches(predicate);
        return myself;
    }

    public SELF isAutoIncremented(boolean expected) {
        return returns(expected, Column::isAutoIncremented);
    }

    public SELF isColumnDataTypeKnown(boolean expected) {
        return returns(expected, BaseColumn::getColumnDataType);
    }

    public SELF isGenerated(boolean expected) {
        return returns(expected, Column::isGenerated);
    }

    public SELF isHidden(boolean expected) {
        return returns(expected, Column::isHidden);
    }

    public SELF isNullable(boolean expected) {
        return returns(expected, BaseColumn::isNullable);
    }

    public SELF isPartOfForeignKey(boolean expected) {
        return returns(expected, Column::isPartOfForeignKey);
    }

    public SELF isPartOfIndex(boolean expected) {
        return returns(expected, Column::isPartOfIndex);
    }

    public SELF isPartOfPrimaryKey(boolean expected) {
        return returns(expected, Column::isPartOfPrimaryKey);
    }

    public SELF isPartOfUniqueIndex(boolean expected) {
        return returns(expected, Column::isPartOfUniqueIndex);
    }

    @SuppressWarnings("unchecked")
    public PrivilegeAssert privilege(String name) {
        return (PrivilegeAssert) extracting(x -> x.lookupPrivilege(name))
                .asInstanceOf(SchemaCrawlerInstanceOfAssertFactories.privilege());
    }

}