DataTableDiffTest.java

package dbfit.diff;

import static dbfit.util.DiffTestUtils.*;
import static dbfit.test.matchers.HasMatchStatus.*;

import dbfit.util.DataTable;
import dbfit.util.DataRow;
import dbfit.util.MatchResult;
import dbfit.util.DiffListenerAdapter;
import dbfit.util.DiffHandler;
import dbfit.util.RowStructure;
import dbfit.util.MatchStatus;
import static dbfit.util.MatchStatus.*;

import org.junit.Test;
import org.junit.Before;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertThat;
import static org.hamcrest.Matchers.*;

import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.Mock;
import org.mockito.Captor;
import org.mockito.ArgumentCaptor;
import static org.mockito.Mockito.*;

import static java.util.Arrays.asList;

@RunWith(MockitoJUnitRunner.class)
public class DataTableDiffTest {

    private RowStructure rowStructure = new RowStructure(
            new String[] { "n", "2n" }, /* names */
            new boolean[] { true, false } /* keys */
        );

    @Mock private DiffHandler handler;
    @Mock DataRowDiff childDiff;
    @Mock MatchResult<DataTable, DataTable> mockRequest;
    @Captor ArgumentCaptor<MatchResult<DataRow, DataRow>> rowResultCaptor;
    @Captor ArgumentCaptor<MatchResult<DataTable, DataTable>> tabResultCaptor;
    @Captor ArgumentCaptor<DataRow> arg1Captor;
    @Captor ArgumentCaptor<DataRow> arg2Captor;

    private DataTableDiff diff;

    DataRow r1 = createRow(1, 2);
    DataRow r2 = createRow(2, 4);
    DataRow r3 = createRow(3, 6);
    DataRow r4 = createRow(4, 8);
    DataRow r5 = createRow(5, 10);
    DataRow b2 = createRow(2, 44);

    @Before
    public void prepare() {
        diff = new DataTableDiff(rowStructure);
        diff.addListener(new DiffListenerAdapter(handler));
        when(mockRequest.getObject1()).thenReturn(createDt(r1));
        when(mockRequest.getObject2()).thenReturn(createDt(r1));
    }

    @Test
    public void shouldInvokeDiffPerEachChildRow() {
        diff = new DataTableDiff(rowStructure, childDiff);

        diff.diff(createDt(r1, r2, r3), createDt(r1, b2, r4));

        verify(childDiff, times(4)).diff(
                arg1Captor.capture(), arg2Captor.capture());

        assertThat(arg1Captor.getAllValues(), contains(r1, r2, r3, null));
        assertThat(arg2Captor.getAllValues(), contains(r1, b2, null, r4));
    }

    @Test
    public void shouldEmitExceptionsAsEvents() {
        diff = new DataTableDiff(rowStructure, childDiff);
        Exception ex = new RuntimeException("Cruel World!");
        doThrow(ex).when(childDiff).diff(anyDataRow(), anyDataRow());

        diff.diff(mockRequest);

        verify(mockRequest).setException(ex);
    }

    @Test
    public void testMismatchWithRightWrongSurplusAndMissing() {
        diff.diff(createDt(r1, r2, r3), createDt(r1, b2, r4));
        verifyRowStatuses(SUCCESS, WRONG, MISSING, SURPLUS);
    }

    @Test
    public void shouldEmitSummaryTableEventOnMismatchingDiff() {
        diff.diff(createDt(r1, r2, r3), createDt(r1, b2, r4));
        verifyTabStatus(WRONG);
    }

    @Test
    public void shouldEmitSummaryTableEventOnMatchingDiff() {
        diff.diff(createDt(r1, r2, r3), createDt(r3, r1, r2));
        verifyTabStatus(SUCCESS);
    }

    @Test
    public void testSingleWrongRow() {
        diff.diff(createDt(r2), createDt(b2));
        verifyRowStatuses(WRONG);
    }

    private void verifyRowStatuses(MatchStatus... expectedStatuses) {
        verify(handler, times(expectedStatuses.length)).endRow(
                rowResultCaptor.capture());

        assertThat(statusesOf(rowResultCaptor.getAllValues()),
                equalTo(asList(expectedStatuses)));
    }

    private void verifyTabStatus(MatchStatus expectedStatus) {
        verify(handler).endTable(tabResultCaptor.capture());
        assertThat(tabResultCaptor.getValue(), hasMatchStatus(expectedStatus));
    }

    private DataRow createRow(Integer... items) {
        return createDataRowBuilder(rowStructure).createRow(items);
    }

    private DataTable createDt(DataRow... rows) {
        return createDataTable(rowStructure, rows);
    }

    private DataRow anyDataRow() {
        return org.mockito.ArgumentMatchers.any();
    }
}