jOOQ assertj assetions

RecordAssert.java

package exemplary.assertj;

import org.assertj.core.api.AbstractObjectAssert;
import org.assertj.core.api.ObjectAssert;
import org.jooq.*;
import org.jooq.Record;
import org.jooq.impl.DSL;

public class RecordAssert<R extends Record> extends AbstractObjectAssert<RecordAssert<R>, R> {

public RecordAssert(R actual) {
    super(actual, RecordAssert.class);
}

@SuppressWarnings("unchecked")
static <T> T get(Record record, Field<T> field) {
    if (field instanceof TableField<?,?>) return field.get(record);

    Name[] parts = field.getQualifiedName().parts();
    Record current = record;
    for (int i = 1; i < parts.length; i++) {
        if (current == null) return null;
        Name part = parts[i];
        Field<?> currentField = current.field(part);
        if (currentField instanceof UDTPathField<?,?,?> udtPath) {
            current = current.get(udtPath, UDTRecord.class);
        } else {
            return (T) current.get(currentField);
        }
    }

    throw new IllegalStateException();
}

public <T> RecordAssert<R> returns(T expected, Field<T> field) {
    return describedAs(field.getName()).returns(expected, r -> get(r,field));
}

public <T1, T2> ObjectAssert<Row2<T1, T2>> extracting(Field<T1> field1, Field<T2> field2) {
    return new ObjectAssert<>(DSL.row(get(actual, field1), get(actual, field2)));
}

public <T1, T2, T3> ObjectAssert<Row3<T1, T2, T3>> extracting(Field<T1> field1, Field<T2> field2, Field<T3> field3) {
    return new ObjectAssert<>(DSL.row(get(actual, field1), get(actual, field2), get(actual, field3)));
}

public <T1, T2, T3, T4> ObjectAssert<Row4<T1, T2, T3, T4>> extracting(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4) {
    return new ObjectAssert<>(DSL.row(get(actual, field1), get(actual, field2), get(actual, field3), get(actual, field4)));
}

}

RecordCollectionAssert.java

package exemplary.assertj;

import org.assertj.core.api.AbstractCollectionAssert;
import org.assertj.core.api.AbstractListAssert;
import org.assertj.core.api.ObjectAssert;
import org.jooq.*;
import org.jooq.Record;
import org.jooq.impl.DSL;

import java.util.ArrayList;
import java.util.List;
import java.util.SequencedCollection;

public class RecordCollectionAssert<R extends Record>
      extends AbstractCollectionAssert<RecordCollectionAssert<R>, SequencedCollection<R>, R, RecordAssert<R>> {

protected RecordCollectionAssert(SequencedCollection<R> actual) {
    super(actual, RecordCollectionAssert.class);
}

@Override
protected RecordAssert<R> toAssert(R value, String description) {
    return new RecordAssert<>(value);
}

@Override
protected RecordCollectionAssert<R> newAbstractIterableAssert(Iterable<? extends R> iterable) {
    ArrayList<R> list = new ArrayList<>();
    iterable.forEach(list::add);
    return new RecordCollectionAssert<>(list);
}

public <T1> AbstractListAssert<?, List<? extends T1>, T1, ObjectAssert<T1>> extracting(Field<T1> field1) {
    return extracting(r -> RecordAssert.get(r, field1));
}

public <T1, T2> AbstractListAssert<?, List<? extends Row2<T1, T2>>, Row2<T1, T2>, ObjectAssert<Row2<T1, T2>>> extracting(Field<T1> field1, Field<T2> field2) {
    return extracting(r -> DSL.row(RecordAssert.get(r, field1), RecordAssert.get(r, field2)));
}

public <T1, T2, T3> AbstractListAssert<?, List<? extends Row3<T1, T2, T3>>, Row3<T1, T2, T3>, ObjectAssert<Row3<T1, T2, T3>>> extracting(Field<T1> field1, Field<T2> field2, Field<T3> field3) {
    return extracting(r -> DSL.row(RecordAssert.get(r, field1), RecordAssert.get(r, field2), RecordAssert.get(r, field3)));
}

public <T1, T2, T3, T4> AbstractListAssert<?, List<? extends Row4<T1, T2, T3, T4>>, Row4<T1, T2, T3, T4>, ObjectAssert<Row4<T1, T2, T3, T4>>> extracting(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4) {
    return extracting(r -> DSL.row(RecordAssert.get(r, field1), RecordAssert.get(r, field2), RecordAssert.get(r, field3), RecordAssert.get(r, field4)));
}

}