How to use

rocks.inspectit.agent.java.event.AgentMessagesReceivedEvent

constructor

/**
 * {@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(expectedExceptions = IllegalArgumentException.class)
public void nullAgentMessages() {
  Object eventSource = mock(Object.class);
  new AgentMessagesReceivedEvent(eventSource, null);
}

  @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 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())));
}

@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
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
@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 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);
}