@Test public void submit_callable_passes_through_to_delegate_with_tracing_wrapper() { // given Callable<?> origTaskMock = mock(Callable.class); Future<?> expectedResultMock = mock(Future.class); doReturn(expectedResultMock).when(executorServiceMock).submit(any(Callable.class)); TracingState expectedTracingState = generateTracingStateOnCurrentThread(); // when Future<?> result = instance.submit(origTaskMock); // then assertThat(result).isSameAs(expectedResultMock); verify(executorServiceMock).submit(callableCaptor.capture()); Callable<?> actualTask = callableCaptor.getValue(); verifyCallableWithTracingWrapper(actualTask, origTaskMock, expectedTracingState); verifyNoMoreInteractions(executorServiceMock); }
@After public void afterMethod() { resetTracing(); }
private void verifyCallableWithTracingWrapper( Callable<?> actual, Callable<?> expectedOrigCallable, TracingState expectedTracingState ) { assertThat(actual).isInstanceOf(CallableWithTracing.class); CallableWithTracing<?> actualWithTracing = (CallableWithTracing<?>) actual; assertThat(actualWithTracing.origCallable).isSameAs(expectedOrigCallable); verifyExpectedTracingState( actualWithTracing.spanStackForExecution, actualWithTracing.mdcContextMapForExecution, expectedTracingState ); }
@Test public void execute_passes_through_to_delegate_with_tracing_wrapped_runnable() { // given Runnable origRunnableMock = mock(Runnable.class); TracingState expectedTracingState = generateTracingStateOnCurrentThread(); // when instance.execute(origRunnableMock); // then verify(executorServiceMock).execute(runnableCaptor.capture()); Runnable actualRunnable = runnableCaptor.getValue(); verifyRunnableWithTracingWrapper(actualRunnable, origRunnableMock, expectedTracingState); verifyNoMoreInteractions(executorServiceMock); }
@Test public void submit_runnable_passes_through_to_delegate_with_tracing_wrapper() { // given Runnable origTaskMock = mock(Runnable.class); Future<?> expectedResultMock = mock(Future.class); doReturn(expectedResultMock).when(executorServiceMock).submit(any(Runnable.class)); TracingState expectedTracingState = generateTracingStateOnCurrentThread(); // when Future<?> result = instance.submit(origTaskMock); // then assertThat(result).isSameAs(expectedResultMock); verify(executorServiceMock).submit(runnableCaptor.capture()); Runnable actualTask = runnableCaptor.getValue(); verifyRunnableWithTracingWrapper(actualTask, origTaskMock, expectedTracingState); verifyNoMoreInteractions(executorServiceMock); }
@Test public void invokeAll_no_timeout_passes_through_to_delegate_with_tracing_wrapped_tasks() throws InterruptedException { // given List<Callable<Object>> origTasks = Arrays.asList(mock(Callable.class), mock(Callable.class)); List<Future<Object>> expectedResultMock = mock(List.class); doReturn(expectedResultMock).when(executorServiceMock).invokeAll(any(Collection.class)); TracingState expectedTracingState = generateTracingStateOnCurrentThread(); // when List<Future<Object>> result = instance.invokeAll(origTasks); // then assertThat(result).isSameAs(expectedResultMock); verify(executorServiceMock).invokeAll(collectionCaptor.capture()); List<Callable<Object>> actualTasks = (List<Callable<Object>>) collectionCaptor.getValue(); assertThat(actualTasks).hasSameSizeAs(origTasks); for (int i = 0; i < actualTasks.size(); i++) { Callable<Object> actualTask = actualTasks.get(i); Callable<Object> origTaskMock = origTasks.get(i); verifyCallableWithTracingWrapper(actualTask, origTaskMock, expectedTracingState); } verifyNoMoreInteractions(executorServiceMock); }
@Test public void submit_runnable_with_result_passes_through_to_delegate_with_tracing_wrapper() { // given Runnable origTaskMock = mock(Runnable.class); String resultArg = UUID.randomUUID().toString(); Future<String> expectedResultMock = mock(Future.class); doReturn(expectedResultMock).when(executorServiceMock).submit(any(Runnable.class), anyString()); TracingState expectedTracingState = generateTracingStateOnCurrentThread(); // when Future<String> result = instance.submit(origTaskMock, resultArg); // then assertThat(result).isSameAs(expectedResultMock); verify(executorServiceMock).submit(runnableCaptor.capture(), eq(resultArg)); Runnable actualTask = runnableCaptor.getValue(); verifyRunnableWithTracingWrapper(actualTask, origTaskMock, expectedTracingState); verifyNoMoreInteractions(executorServiceMock); }
private void verifyRunnableWithTracingWrapper( Runnable actual, Runnable expectedOrigRunnable, TracingState expectedTracingState ) { assertThat(actual).isInstanceOf(RunnableWithTracing.class); RunnableWithTracing actualWithTracing = (RunnableWithTracing) actual; assertThat(actualWithTracing.origRunnable).isSameAs(expectedOrigRunnable); verifyExpectedTracingState( actualWithTracing.spanStackForExecution, actualWithTracing.mdcContextMapForExecution, expectedTracingState ); }
@Before public void beforeMethod() { executorServiceMock = mock(ExecutorService.class); instance = new ExecutorServiceWithTracing(executorServiceMock); callableCaptor = ArgumentCaptor.forClass(Callable.class); runnableCaptor = ArgumentCaptor.forClass(Runnable.class); collectionCaptor = ArgumentCaptor.forClass(Collection.class); resetTracing(); }
@Test public void invokeAny_no_timeout_passes_through_to_delegate_with_tracing_wrapped_tasks() throws InterruptedException, ExecutionException { // given List<Callable<Object>> origTasks = Arrays.asList(mock(Callable.class), mock(Callable.class)); Object expectedResultMock = mock(Object.class); doReturn(expectedResultMock).when(executorServiceMock).invokeAny(any(Collection.class)); TracingState expectedTracingState = generateTracingStateOnCurrentThread(); // when Object result = instance.invokeAny(origTasks); // then assertThat(result).isSameAs(expectedResultMock); verify(executorServiceMock).invokeAny(collectionCaptor.capture()); List<Callable<Object>> actualTasks = (List<Callable<Object>>) collectionCaptor.getValue(); assertThat(actualTasks).hasSameSizeAs(origTasks); for (int i = 0; i < actualTasks.size(); i++) { Callable<Object> actualTask = actualTasks.get(i); Callable<Object> origTaskMock = origTasks.get(i); verifyCallableWithTracingWrapper(actualTask, origTaskMock, expectedTracingState); } verifyNoMoreInteractions(executorServiceMock); }
@Test public void invokeAll_with_timeout_passes_through_to_delegate_with_tracing_wrapped_tasks() throws InterruptedException { // given List<Callable<Object>> origTasks = Arrays.asList(mock(Callable.class), mock(Callable.class)); List<Future<Object>> expectedResultMock = mock(List.class); doReturn(expectedResultMock).when(executorServiceMock) .invokeAll(any(Collection.class), anyLong(), any(TimeUnit.class)); long timeoutValue = 42; TimeUnit timeoutTimeUnit = TimeUnit.MINUTES; TracingState expectedTracingState = generateTracingStateOnCurrentThread(); // when List<Future<Object>> result = instance.invokeAll(origTasks, timeoutValue, timeoutTimeUnit); // then assertThat(result).isSameAs(expectedResultMock); verify(executorServiceMock).invokeAll(collectionCaptor.capture(), eq(timeoutValue), eq(timeoutTimeUnit)); List<Callable<Object>> actualTasks = (List<Callable<Object>>) collectionCaptor.getValue(); assertThat(actualTasks).hasSameSizeAs(origTasks); for (int i = 0; i < actualTasks.size(); i++) { Callable<Object> actualTask = actualTasks.get(i); Callable<Object> origTaskMock = origTasks.get(i); verifyCallableWithTracingWrapper(actualTask, origTaskMock, expectedTracingState); } verifyNoMoreInteractions(executorServiceMock); }
@Test public void invokeAny_with_timeout_passes_through_to_delegate_with_tracing_wrapped_tasks() throws InterruptedException, TimeoutException, ExecutionException { // given List<Callable<Object>> origTasks = Arrays.asList(mock(Callable.class), mock(Callable.class)); Object expectedResultMock = mock(Object.class); doReturn(expectedResultMock).when(executorServiceMock) .invokeAny(any(Collection.class), anyLong(), any(TimeUnit.class)); long timeoutValue = 42; TimeUnit timeoutTimeUnit = TimeUnit.MINUTES; TracingState expectedTracingState = generateTracingStateOnCurrentThread(); // when Object result = instance.invokeAny(origTasks, timeoutValue, timeoutTimeUnit); // then assertThat(result).isSameAs(expectedResultMock); verify(executorServiceMock).invokeAny(collectionCaptor.capture(), eq(timeoutValue), eq(timeoutTimeUnit)); List<Callable<Object>> actualTasks = (List<Callable<Object>>) collectionCaptor.getValue(); assertThat(actualTasks).hasSameSizeAs(origTasks); for (int i = 0; i < actualTasks.size(); i++) { Callable<Object> actualTask = actualTasks.get(i); Callable<Object> origTaskMock = origTasks.get(i); verifyCallableWithTracingWrapper(actualTask, origTaskMock, expectedTracingState); } verifyNoMoreInteractions(executorServiceMock); }
@Test public void convertToCallableWithTracingList_works_as_expected() { // given List<Callable<Object>> origCallables = Arrays.asList( mock(Callable.class), null, mock(Callable.class) ); TracingState expectedTracingState = generateTracingStateOnCurrentThread(); // when List<Callable<Object>> results = instance.convertToCallableWithTracingList(origCallables); // then assertThat(results).hasSameSizeAs(origCallables); for (int i = 0; i < results.size(); i++) { Callable<Object> actualTask = results.get(i); Callable<Object> origTaskMock = origCallables.get(i); if (origTaskMock == null) { assertThat(actualTask).isNull(); } else { verifyCallableWithTracingWrapper(actualTask, origTaskMock, expectedTracingState); } } }