Moyen facile de remplir jeu de résultats avec des données

DBUnit n'est pas de présenter un ensemble de résultats, à ma connaissance, mais il faudra bien vous aider à remplir votre dans la mémoire de la base de données.

Je dirais qu'un moqueur cadre est la mauvaise approche à ce point. Se moquant est sur les tests de comportement et d'interaction, et pas seulement les données de retour, de sorte qu'il sera probablement obtenir sur votre chemin.

Je serait plutôt de mettre en place un ensemble de résultats de l'interface ou de créer une dynamique de proxy d'un jeu de résultat de l'interface d'une classe qui implémente les méthodes de soins, sans avoir à mettre en œuvre la totalité des résultats. Vous trouverez probablement le maintien d'une classe aussi facile que de maintenir une mémoire de base de données (à condition que le jeu de données de test est compatible), et probablement plus facile à déboguer.

Vous pouvez sauvegarder cette classe avec DBUnit, où vous prenez un instantané de votre jeu de résultats avec dbunit, et ont dbunit le lire pendant le test à partir de xml, et vous avez votre mannequin ensemble de résultats de lire les données à partir de dbunit de classes. Ce serait une approche raisonnable si les données ont été légèrement complexe.

Je pencherais pour la mémoire de la base de données si les classes sont ainsi couplés qu'ils ont besoin de lire les données qui ont été modifiées dans le cadre de la même test. Même alors, je voudrais envisager d'utiliser une copie de la base de données réelle jusqu'à ce que vous avez réussi à tirer la dépendance en dehors.

Un simple proxy méthode de génération:

private static class SimpleInvocationHandler implements InvocationHandler {
    private Object invokee;

    public SimpleInvocationHandler(Object invokee) {
        this.invokee = invokee;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        method = invokee.getClass().getMethod(method.getName(), method.getParameterTypes());
        if (!method.isAccessible()) {
            method.setAccessible(true);
        }
        try {
            return method.invoke(invokee, args);
        } catch (InvocationTargetException e) {
            throw e.getTargetException();
        }
    }
}

public static <T> T generateProxy(Object realObject, Class... interfaces) {
    return (T) Proxy.newProxyInstance(realObject.getClass().getClassLoader(), interfaces, new SimpleInvocationHandler(realObject));
}

J'ai écrit quelque chose pour cette même affaire. Vous pouvez simuler le jeu de résultats à l'aide de Mockito. Vous pouvez ainsi en boucle sur la maquette lignes du jeu de résultats en se moquant du jeu de résultats.next() avec ce morceau de code.

//two dimensional array mocking the rows of database.
String[][] result = { { "column1", "column2" }, { "column1", "column2" } };
@InjectMocks
@Spy
private TestableClass testableClass;
@Mock
private Connection connection;
@Mock
private Statement statement;
@Mock
private ResultSet resultSet;
@BeforeTest
public void beforeTest() {
MockitoAnnotations.initMocks(this);
}
@BeforeMethod
public void beforeMethod() throws SQLException {
doAnswer(new Answer<Connection>() {
public Connection answer(InvocationOnMock invocation)
throws Throwable {
return connection;
}
}).when(testableClass).getConnection();
when(connection.createStatement()).thenReturn(statement);
when(statement.executeQuery(anyString())).thenReturn(resultSet);
final AtomicInteger idx = new AtomicInteger(0);
final MockRow row = new MockRow();
doAnswer(new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
int index = idx.getAndIncrement();
if (result.length > index) {
String[] current = result[index];
row.setCurrentRowData(current);
return true;
} else
return false;
}
;
}).when(resultSet).next();
doAnswer(new Answer<String>() {
@Override
public String answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
int idx = ((Integer) args[0]).intValue();
return row.getColumn(idx);
}
;
}).when(resultSet).getString(anyInt());
}
static class MockRow {
String[] rowData;
public void setCurrentRowData(String[] rowData) {
this.rowData = rowData;
}
public String getColumn(int idx) {
return rowData[idx - 1];
}
}

Le cas échéant, vous pourriez vous prenez le jeu de résultats, vous avez maintenant à partir de votre véritable source de données, le sérialiser, et enregistrez le fichier. Ensuite, vous pouvez désérialiser l'ensemble des résultats pour chacun de vos tests unitaires, et vous devriez être bon d'aller.