How to use rocks.inspectit.agent.java.event

/**
 * {@inheritDoc}
 */
@Override
public void run() {
  try {
    List<IAgentMessage<?>> messages = fetchMessages();
    if (CollectionUtils.isNotEmpty(messages)) {
      AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(this, messages);
      eventPublisher.publishEvent(event);
    }
  } catch (Exception e) {
    if (log.isWarnEnabled()) {
      log.warn("An unexpected exception ocurred.", e);
    }
  }
}

@Test
public void successful() {
  Object eventSource = mock(Object.class);
  IAgentMessage<?> message = mock(IAgentMessage.class);
  List<IAgentMessage<?>> messages = Arrays.<IAgentMessage<?>> asList(message);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, messages);
  assertThat(eventSource, is(equalTo(event.getSource())));
  assertThat(messages, is(equalTo(event.getAgentMessages())));
}

/**
 * {@inheritDoc}
 */
@Override
public void onApplicationEvent(AgentMessagesReceivedEvent event) {
  if (event == null) {
    if (log.isDebugEnabled()) {
      log.debug("A 'null' event will not be processed.");
    }
    return;
  }
  // When we update to Spring v4, we should use @Conditional that the RetransformationManager
  // is not running if retransformation is not used.
  if (!Agent.agent.isUsingRetransformation()) {
    if (log.isInfoEnabled()) {
      log.info("Retransformation is disabled by the used retransformation strategy.");
    }
    return;
  }
  List<InstrumentationDefinition> instrumentationDefinitions = getInstrumentatioDefinitions(event.getAgentMessages());
  if (CollectionUtils.isEmpty(instrumentationDefinitions)) {
    return;
  }
  // remove out-dated duplicates
  Collection<InstrumentationDefinition> cleanedInstrumentationDefinitions = removeOutdatedInstrumentationDefinitions(instrumentationDefinitions);
  processInstrumentationDefinitions(cleanedInstrumentationDefinitions);
}

@Test(expectedExceptions = IllegalArgumentException.class)
public void nullAgentMessages() {
  Object eventSource = mock(Object.class);
  new AgentMessagesReceivedEvent(eventSource, null);
}

@Test
public void successful() throws Exception {
  when(connection.isConnected()).thenReturn(true);
  when(platformManager.getPlatformId()).thenReturn(10L);
  List<IAgentMessage<?>> messages = Arrays.<IAgentMessage<?>> asList(mock(IAgentMessage.class));
  when(connection.fetchAgentMessages(10L)).thenReturn(messages);
  messageFetcher.run();
  verify(connection).isConnected();
  verify(connection).fetchAgentMessages(10L);
  verify(platformManager).getPlatformId();
  ArgumentCaptor<AgentMessagesReceivedEvent> eventCaptor = ArgumentCaptor.forClass(AgentMessagesReceivedEvent.class);
  verify(eventPublisher).publishEvent(eventCaptor.capture());
  verifyNoMoreInteractions(connection, eventPublisher, platformManager);
  assertThat(eventCaptor.getValue().getAgentMessages(), is(equalTo(messages)));
}

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void nullEventSource() {
    IAgentMessage<?> message = mock(IAgentMessage.class);
    List<IAgentMessage<?>> messages = Arrays.<IAgentMessage<?>> asList(message);
    new AgentMessagesReceivedEvent(null, messages);
  }
}

@Test
public void unknownMessageClass() throws UnmodifiableClassException {
  IAgentMessage<?> message = mock(IAgentMessage.class);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verifyZeroInteractions(instrumentation, classHashHelper, threadTransformHelper);
}

@Test
public void noInstrumentationDefinitions() throws UnmodifiableClassException {
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verifyZeroInteractions(instrumentation, classHashHelper, threadTransformHelper);
}

  @Test
  public void retransformationDisabled() throws UnmodifiableClassException {
    InstrumentationDefinition objectDefinition = mock(InstrumentationDefinition.class);
    when(objectDefinition.getClassName()).thenReturn("java.lang.Object");
    IAgentMessage<?> message = new UpdatedInstrumentationMessage();
    ((UpdatedInstrumentationMessage) message).getMessageContent().add(objectDefinition);
    AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
    when(agent.isUsingRetransformation()).thenReturn(false);
    retransformManager.onApplicationEvent(event);
    verifyZeroInteractions(instrumentation, classHashHelper, threadTransformHelper);
  }
}

@Test
public void unmodifiableClass() throws UnmodifiableClassException {
  InstrumentationDefinition iDefinition = mock(InstrumentationDefinition.class);
  when(iDefinition.getClassName()).thenReturn("java.lang.Object");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(iDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(instrumentation.isModifiableClass(eq(Object.class))).thenReturn(false);
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.Object"), eq(iDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  verifyNoMoreInteractions(instrumentation, classHashHelper);
  verifyZeroInteractions(threadTransformHelper);
}

@Test
public void unknownInstrumentationClass() throws UnmodifiableClassException {
  InstrumentationDefinition iDefinition = mock(InstrumentationDefinition.class);
  when(iDefinition.getClassName()).thenReturn("unknown.Class");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(iDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("unknown.Class"), eq(iDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  verifyNoMoreInteractions(instrumentation, classHashHelper);
  verifyZeroInteractions(threadTransformHelper);
}

@Test
@SuppressWarnings("unchecked")
public void instrumentationThrowsOneException() throws UnmodifiableClassException {
  InstrumentationDefinition iDefinition = mock(InstrumentationDefinition.class);
  when(iDefinition.getClassName()).thenReturn("java.lang.Object");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(iDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(instrumentation.isModifiableClass(any(Class.class))).thenReturn(true).thenThrow(RuntimeException.class);
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.Object"), eq(iDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation).retransformClasses(eq(Object.class));
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  InOrder inOrder = inOrder(threadTransformHelper);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(false);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(true);
  verifyNoMoreInteractions(instrumentation, classHashHelper, threadTransformHelper);
}

@Test
public void retransformationThrowsException() throws UnmodifiableClassException {
  InstrumentationDefinition iDefinition = mock(InstrumentationDefinition.class);
  when(iDefinition.getClassName()).thenReturn("java.lang.Object");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(iDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  doThrow(Exception.class).when(instrumentation).retransformClasses(any(Class.class));
  when(instrumentation.isModifiableClass(Matchers.<Class<?>> any())).thenReturn(true);
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.Object"), eq(iDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation).retransformClasses(any(Class.class));
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  InOrder inOrder = inOrder(threadTransformHelper);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(false);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(true);
  verifyNoMoreInteractions(instrumentation, classHashHelper);
  verifyZeroInteractions(threadTransformHelper);
}

@Test
public void successful() throws UnmodifiableClassException {
  InstrumentationDefinition objectDefinition = mock(InstrumentationDefinition.class);
  when(objectDefinition.getClassName()).thenReturn("java.lang.Object");
  InstrumentationDefinition stringDefinition = mock(InstrumentationDefinition.class);
  when(stringDefinition.getClassName()).thenReturn("java.lang.String");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(objectDefinition);
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(stringDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(instrumentation.isModifiableClass(any(Class.class))).thenReturn(true);
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.Object"), eq(objectDefinition));
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.String"), eq(stringDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation).retransformClasses(eq(Object.class), eq(String.class));
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  verify(agent).isUsingRetransformation();
  InOrder inOrder = inOrder(threadTransformHelper);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(false);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(true);
  verifyNoMoreInteractions(instrumentation, classHashHelper, threadTransformHelper, agent);
}