Utilisation de jmock comment réutiliser le paramètre

Question

Je construis un test dans lequel je dois envoyer une question et attendre la réponse. Le passage de message n'est pas le problème. En fait, pour savoir quelle réponse correspond à quelle question, j'utilise un identifiant. Mon identifiant est généré à l'aide d'un UUID. Je veux récupérer cet identifiant, qui est donné en paramètre à un objet mocké. Il ressemble à ceci:

oneOf(message).setJMSCorrelationID(with(correlationId)); 
      inSequence(sequence); 

Où correlationId est la chaîne que je voudrais garder pour une autre expecteation comme celui-ci:

oneOf(session).createBrowser(with(inputChannel), 
      with("JMSType ='pong' AND JMSCorrelationId = '"+correlationId+"'")); 

Avez-vous une réponse?

Answer 1

Une autre option à considérer, où l'ID de corrélation ne vient? Est-ce que cette activité doit être injectée pour que vous puissiez la contrôler et la vérifier dans le test?

Answer 2

Vous devez créer vos propres actions. Voici le mien:

/** 
* puts the parameter array as elements in the list 
* @param parameters A mutable list, will be cleared when the Action is invoked. 
*/ 
public static Action captureParameters(final List<Object> parameters) { 
    return new CustomAction("captures parameters") { 
     public Object invoke(Invocation invocation) throws Throwable { 
      parameters.clear(); 
      parameters.addAll(Arrays.asList(invocation.getParametersAsArray())); 
      return null; 
     } 
    }; 
} 

Vous utilisez ensuite comme ceci (avec une importation statique):

final List<Object> parameters = new ArrayList<Object>(); 
    final SomeInterface services = context.mock(SomeInterface.class); 
    context.checking(new Expectations() {{ 
     oneOf(services).createNew(with(6420), with(aNonNull(TransactionAttributes.class))); 
      will(doAll(captureParameters(parameters), returnValue(true))); 
    }}); 

Pour faire ce que vous voulez, vous devez implémenter votre propre matcher. Voilà ce que je piraté en (un peu nulle vérification à l'écart, et bien sûr j'utiliser simplement des interfaces bien connues pour l'échantillon):

@RunWith(JMock.class) 
public class Scrap { 

private Mockery context = new JUnit4Mockery(); 

@Test 
public void testCaptureParameters() throws Exception { 
    final CharSequence mock = context.mock(CharSequence.class); 
    final ResultSet rs = context.mock(ResultSet.class); 
    final List<Object> parameters = new ArrayList<Object>(); 
    context.checking(new Expectations(){{ 
     oneOf(mock).charAt(10); 
      will(doAll(JMockActions.captureParameters(parameters), returnValue((char) 0))); 
     oneOf(rs).getInt(with(new ParameterMatcher<Integer>(parameters, 0))); 
    }}); 

    mock.charAt(10); 
    rs.getInt(10); 
} 

private static class ParameterMatcher<T> extends BaseMatcher<T> { 
    private List<?> parameters; 
    private int index; 

    private ParameterMatcher(List<?> parameters, int index) { 
     this.parameters = parameters; 
     this.index = index; 
    } 

    public boolean matches(Object item) { 
     return item.equals(parameters.get(index)); 
    } 

    public void describeTo(Description description) { 
     description.appendValue(parameters.get(index)); 
    } 
} 
} 

Answer 3

J'ai trouvé une autre solution sur ce site http://www.symphonious.net/2010/03/09/returning-parameters-in-jmock-2/

import org.hamcrest.*; 
import org.jmock.api.*; 

public class CapturingMatcher<T> extends BaseMatcher<T> implements Action { 
public T captured; 

public boolean matches(Object o) { 
    try { 
     captured = (T)o; 
     return true; 
    } catch (ClassCastException e) { 
     return false; 
    } 
} 

public void describeTo(Description description) { 
    description.appendText("captured value "); 
    description.appendValue(captured); 
} 

public Object invoke(Invocation invocation) throws Throwable { 
    return captured; 
} 
} 

Il peut alors être utilisé comme:

context.checking(new Expectations() {{ 
CapturingMatcher<String> returnCapturedValue = new CapturingMatcher<String>(); 
allowing(mockObject).getParameter(with(equal("expectedParameterName")), with(returnCapturedValue)); will(returnCapturedValue); 
}});