@BeforeMethod public void init() { // can not use @InjectMocks as span store gets injected to listener place proxy = new JettyEventListenerProxy(null, spanStore); }
@Test public void withoutSpanStoreAndCallback() throws Exception { removeOriginalCallback(); proxy.cancelled(); verify(spanStoreAdapter).getSpanStore(); verifyNoMoreInteractions(spanStoreAdapter); verifyZeroInteractions(spanStore, originalCallback); } }
@Test public void listenerProvided() { Object originalListener = new Object(); proxy = new JettyEventListenerProxy(originalListener, spanStore); Object[] args = proxy.getProxyConstructorArguments(); assertThat(args, is(new Object[] { originalListener, Boolean.TRUE })); } }
@Test public void withoutSpanStore() throws Exception { Exception exception = new Exception(); proxy.failed(exception); verify(spanStoreAdapter).getSpanStore(); verify(originalCallback).failed(exception); verifyNoMoreInteractions(spanStoreAdapter, originalCallback); verifyZeroInteractions(spanStore); }
/** * {@inheritDoc} */ @Override public Object beforeBody(long methodId, Object object, Object[] parameters, SpecialSensorConfig ssc) { if ((null != parameters) && (parameters.length == 4)) { // the HTTP context Object httpContext = parameters[2]; // the original callback given by the user Object originalCallback = parameters[3]; SpanStoreAdapter spanStoreAdapter = new ApacheHttpContextSpanStoreAdapter(httpContext); FutureCallbackProxy proxy = new FutureCallbackProxy(originalCallback, spanStoreAdapter); Object newProxy = runtimeLinker.createProxy(FutureCallbackProxy.class, proxy, object.getClass().getClassLoader()); parameters[3] = newProxy; } return null; }
@Test public void withoutSpanStoreAndCallback() throws Exception { Exception exception = new Exception(); removeOriginalCallback(); proxy.failed(exception); verify(spanStoreAdapter).getSpanStore(); verifyNoMoreInteractions(spanStoreAdapter); verifyZeroInteractions(spanStore, originalCallback); } }
@Test public void withoutSpanStoreAndCallback() throws Exception { Object response = new Object(); removeOriginalCallback(); proxy.completed(response); verify(spanStoreAdapter).getSpanStore(); verifyNoMoreInteractions(spanStoreAdapter); verifyZeroInteractions(spanStore, originalCallback); } }
@Test public void happyPath() throws IOException { int status = 200; proxy.onResponseStatus("version", status, "reason"); verifyZeroInteractions(spanStore); assertThat(proxy.getStatus(), is(status)); } }
/** * Connection failed. * * @param ex * Throwable */ @ProxyMethod(parameterTypes = "java.lang.Throwable") public void onConnectionFailed(Throwable ex) { handleThrowable(ex); if (null != originalListener) { WHttpEventListenerWrapper.ON_CONNECTION_FAILED.call(originalListener, ex); } }
@Test public void returnsAnEmptyCollection() { Object[] args = proxy.getProxyConstructorArguments(); assertThat("Number of args returned by the constructor must be zero.", args, is(new Object[] {})); } }
@Test public void listenerNull() { Object[] args = proxy.getProxyConstructorArguments(); assertThat(args, is(new Object[] { null, Boolean.FALSE })); }
@Test public void happyPath() throws IOException { proxy.onRequestCommitted(); verify(spanStore).startSpan(); } }
/** * {@inheritDoc} */ @Override public void setSpanStore(SpanStore spanStore) { // get original request listener Object originalListener = cache.invokeMethod(jettyHttpExchange.getClass(), "getEventListener", new Class<?>[] {}, jettyHttpExchange, new Object[] {}, null); // create proxy for this listener JettyEventListenerProxy listenerProxy = new JettyEventListenerProxy(originalListener, spanStore); Object proxyObject = runtimeLinker.createProxy(JettyEventListenerProxy.class, listenerProxy, jettyHttpExchange.getClass().getClassLoader()); // find the interface event listener interface, it's in the super-class of the proxy Class<?> eventListenerClass = proxyObject.getClass().getSuperclass().getInterfaces()[0]; // replace with our listener cache.invokeMethod(jettyHttpExchange.getClass(), "setEventListener", new Class<?>[] { eventListenerClass }, jettyHttpExchange, new Object[] { proxyObject }, null); }
@Test public void successful() throws Exception { when(spanStoreAdapter.getSpanStore()).thenReturn(spanStore); proxy.cancelled(); ArgumentCaptor<TagsProvidingAdapter> captor = ArgumentCaptor.forClass(TagsProvidingAdapter.class); verify(spanStoreAdapter).getSpanStore(); verify(spanStore).finishSpan(captor.capture()); verify(originalCallback).cancelled(); verifyNoMoreInteractions(spanStore, spanStoreAdapter, originalCallback); assertThat(captor.getValue().getTags(), hasKey(SpanStoreAdapter.Constants.CANCEL)); }
@Test public void successful() { Object response = new Object(); when(spanStoreAdapter.getSpanStore()).thenReturn(spanStore); proxy.completed(response); verify(spanStoreAdapter).getSpanStore(); verify(spanStore).finishSpan((HttpResponseAdapter) any()); verify(originalCallback).completed(response); verifyNoMoreInteractions(spanStore, spanStoreAdapter, originalCallback); }
@Test public void successful() throws Exception { Exception exception = new Exception(); when(spanStoreAdapter.getSpanStore()).thenReturn(spanStore); proxy.failed(exception); verify(spanStoreAdapter).getSpanStore(); verify(spanStore).finishSpan((TagsProvidingAdapter) any()); verify(originalCallback).failed(exception); verifyNoMoreInteractions(spanStore, spanStoreAdapter, originalCallback); }
@BeforeMethod public void init() throws Exception { proxy = new FutureCallbackProxy(originalCallback, spanStoreAdapter); WFutureCallback.completed = new CachedMethod<Void>(FutureCallback.class.getName(), "completed", Object.class); WFutureCallback.failed = new CachedMethod<Void>(FutureCallback.class.getName(), "failed", Exception.class); WFutureCallback.cancelled = new CachedMethod<Void>(FutureCallback.class.getName(), "cancelled"); }
/** * Exception occurred. * * @param ex * Throwable */ @ProxyMethod(parameterTypes = "java.lang.Throwable") public void onException(Throwable ex) { handleThrowable(ex); if (null != originalListener) { WHttpEventListenerWrapper.ON_EXCEPTION.call(originalListener, ex); } }