How to use

getInstrumentationAppliers

method

in

rocks.inspectit.server.instrumentation.config.ConfigurationResolver

@Test
public void nullEnvironment() {
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(null);
  assertThat(appliers, is(empty()));
  verifyZeroInteractions(functionalAssignmentFactory, configurationInterfaceManager);
}

/**
 * Updates the defined configuration in the holder with following tasks:<br>
 * 1. Creates the new {@link #agentConfiguration} for given environment and platform id<br>
 * 2. Resolves all {@link #instrumentationAppliers} for given environment<br>
 * 3. sets the passes environment to the holder.
 * <p>
 * If <code>null</code> is passed then everything saved in the holder will be reset to
 * <code>null</code> as well.
 *
 * @param environment
 *            Environment to update the configuration and appliers with.
 * @param platformId
 *            Agent id needed for resolving configuration.
 */
public void update(Environment environment, long platformId) {
  if (null != environment) {
    this.environment = environment;
    this.agentConfiguration = configurationCreator.environmentToConfiguration(environment, platformId);
    this.instrumentationAppliers = configurationResolver.getInstrumentationAppliers(environment);
    this.jmxMonitoringAppliers = configurationResolver.getJmxMonitoringAppliers(environment);
  } else {
    this.environment = null; // NOPMD
    this.agentConfiguration = null; // NOPMD
    this.instrumentationAppliers = null; // NOPMD
    this.jmxMonitoringAppliers = null; // NOPMD
  }
}

@Test
public void noProfile() {
  when(environment.getProfileIds()).thenReturn(Collections.<String> emptySet());
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, is(empty()));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}

@Test
public void specialAssignments() {
  SpecialMethodSensorAssignment assignment = mock(SpecialMethodSensorAssignment.class);
  when(functionalAssignmentFactory.getSpecialAssignments(environment)).thenReturn(Collections.singletonList(assignment));
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(SpecialInstrumentationApplier.class)));
  assertThat((SpecialMethodSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}

@Test
public void profileDoesNotExists() throws BusinessException {
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenThrow(new BusinessException(null));
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, is(empty()));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}

@Test
public void methodSensorAssignment() throws BusinessException {
  MethodSensorAssignment assignment = mock(MethodSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(MethodSensorInstrumentationApplier.class)));
  assertThat((MethodSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}

@Test
public void profileNotActive() throws BusinessException {
  MethodSensorAssignment assignment = mock(MethodSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(false);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, is(empty()));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
  verifyZeroInteractions(assignment);
}

@Test
public void wrongProfileData() throws BusinessException {
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(new ExcludeRulesProfileData()).when(profile).getProfileData();
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, is(empty()));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}

@Test
public void invocationStartsSensorAssignment() throws BusinessException {
  InvocationStartMethodSensorAssignment assignment = mock(InvocationStartMethodSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(InvocationStartMethodSensorInstrumentationApplier.class)));
  assertThat((InvocationStartMethodSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}

@Test
public void timerSensorAssignment() throws BusinessException {
  TimerMethodSensorAssignment assignment = mock(TimerMethodSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(TimerMethodSensorInstrumentationApplier.class)));
  assertThat((TimerMethodSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}

@Test
public void exceptionSensorAssignment() throws BusinessException {
  ExceptionSensorAssignment assignment = mock(ExceptionSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(ExceptionSensorInstrumentationApplier.class)));
  assertThat((ExceptionSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}

  @Test
  public void updateReset() {
    long platformId = 11;
    Environment environment = mock(Environment.class);
    AgentConfig configuration = mock(AgentConfig.class);
    IInstrumentationApplier applier = mock(IInstrumentationApplier.class);
    JmxMonitoringApplier jmxApplier = mock(JmxMonitoringApplier.class);
    when(configurationCreator.environmentToConfiguration(environment, platformId)).thenReturn(configuration);
    when(configurationResolver.getInstrumentationAppliers(environment)).thenReturn(Collections.singleton(applier));
    when(configurationResolver.getJmxMonitoringAppliers(environment)).thenReturn(Collections.singleton(jmxApplier));
    holder.update(environment, platformId);
    holder.update(null, platformId);
    assertThat(holder.isInitialized(), is(false));
    // only one time verifications
    verify(configurationCreator).environmentToConfiguration(environment, platformId);
    verify(configurationResolver).getInstrumentationAppliers(environment);
    verify(configurationResolver).getJmxMonitoringAppliers(environment);
    verifyNoMoreInteractions(configurationCreator, configurationResolver);
  }
}

@Test
public void update() {
  long platformId = 11;
  Environment environment = mock(Environment.class);
  AgentConfig configuration = mock(AgentConfig.class);
  IInstrumentationApplier applier = mock(IInstrumentationApplier.class);
  JmxMonitoringApplier jmxApplier = mock(JmxMonitoringApplier.class);
  when(configurationCreator.environmentToConfiguration(environment, platformId)).thenReturn(configuration);
  when(configurationResolver.getInstrumentationAppliers(environment)).thenReturn(Collections.singleton(applier));
  when(configurationResolver.getJmxMonitoringAppliers(environment)).thenReturn(Collections.singleton(jmxApplier));
  holder.update(environment, platformId);
  assertThat(holder.isInitialized(), is(true));
  assertThat(holder.getEnvironment(), is(environment));
  assertThat(holder.getAgentConfiguration(), is(configuration));
  assertThat(holder.getInstrumentationAppliers(), hasSize(1));
  assertThat(holder.getInstrumentationAppliers(), hasItem(applier));
  assertThat(holder.getJmxMonitoringAppliers(), hasSize(1));
  assertThat(holder.getJmxMonitoringAppliers(), hasItem(jmxApplier));
  verify(configurationCreator).environmentToConfiguration(environment, platformId);
  verify(configurationResolver).getInstrumentationAppliers(environment);
  verify(configurationResolver).getJmxMonitoringAppliers(environment);
  verifyNoMoreInteractions(configurationCreator, configurationResolver);
}