import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
+import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.server.ServerSide;
import org.sonar.api.utils.log.Loggers;
import org.sonar.db.ce.CeTaskCharacteristicDto;
import org.sonar.db.ce.DeleteIf;
import org.sonar.db.component.ComponentDto;
+import org.sonar.db.user.UserDto;
import org.sonar.server.organization.DefaultOrganizationProvider;
import org.sonar.server.property.InternalProperties;
Map<String, ComponentDto> componentsByUuid = loadComponentDtos(dbSession, taskDto);
if (componentsByUuid.isEmpty()) {
- return of(convertToTask(taskDto, submission.getCharacteristics(), null, null));
+ return of(convertToTask(dbSession, taskDto, submission.getCharacteristics(), null, null));
}
- return of(convertToTask(taskDto, submission.getCharacteristics(),
+ return of(convertToTask(dbSession, taskDto, submission.getCharacteristics(),
ofNullable(taskDto.getComponentUuid()).map(componentsByUuid::get).orElse(null),
ofNullable(taskDto.getMainComponentUuid()).map(componentsByUuid::get).orElse(null)));
}
.orElse(null);
Map<String, String> characteristics = characteristicsByTaskUuid.get(dto.getUuid()).stream()
.collect(uniqueIndex(CeTaskCharacteristicDto::getKey, CeTaskCharacteristicDto::getValue));
- result.add(convertToTask(dto, characteristics, component, mainComponent));
+ result.add(convertToTask(dbSession, dto, characteristics, component, mainComponent));
}
return result;
}
}
}
- CeTask convertToTask(CeQueueDto taskDto, Map<String, String> characteristics, @Nullable ComponentDto component, @Nullable ComponentDto mainComponent) {
+ CeTask convertToTask(DbSession dbSession, CeQueueDto taskDto, Map<String, String> characteristics, @Nullable ComponentDto component, @Nullable ComponentDto mainComponent) {
CeTask.Builder builder = new CeTask.Builder()
.setUuid(taskDto.getUuid())
.setType(taskDto.getTaskType())
- .setSubmitterUuid(taskDto.getSubmitterUuid())
- .setCharacteristics(characteristics);
+ .setCharacteristics(characteristics)
+ .setSubmitter(resolveSubmitter(dbSession, taskDto.getSubmitterUuid()));
+
String componentUuid = taskDto.getComponentUuid();
if (component != null) {
return builder.build();
}
+ @CheckForNull
+ private CeTask.User resolveSubmitter(DbSession dbSession, @Nullable String submitterUuid) {
+ if (submitterUuid == null) {
+ return null;
+ }
+ UserDto submitterDto = dbClient.userDao().selectByUuid(dbSession, submitterUuid);
+ if (submitterDto != null) {
+ return new CeTask.User(submitterUuid, submitterDto.getLogin());
+ } else {
+ return new CeTask.User(submitterUuid, null);
+ }
+ }
+
}
import org.sonar.db.ce.CeTaskTypes;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.ComponentTesting;
+import org.sonar.db.user.UserDto;
+import org.sonar.db.user.UserTesting;
import org.sonar.server.organization.DefaultOrganizationProvider;
import org.sonar.server.organization.TestDefaultOrganizationProvider;
String componentUuid = randomAlphabetic(3);
String mainComponentUuid = randomAlphabetic(4);
CeTaskSubmit taskSubmit = createTaskSubmit(CeTaskTypes.REPORT, new Component(componentUuid, mainComponentUuid), "submitter uuid");
+ UserDto userDto = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit.getSubmitterUuid());
CeTask task = underTest.submit(taskSubmit);
- verifyCeTask(taskSubmit, task, null);
+ verifyCeTask(taskSubmit, task, null, userDto);
verifyCeQueueDtoForTaskSubmit(taskSubmit);
}
CeTask task = underTest.submit(taskSubmit);
- verifyCeTask(taskSubmit, task, componentDto);
+ verifyCeTask(taskSubmit, task, componentDto, null);
}
@Test
CeTask task = underTest.submit(taskSubmit);
- verifyCeTask(taskSubmit, task, null);
+ verifyCeTask(taskSubmit, task, null, null);
+ }
+
+ @Test
+ public void submit_populates_submitter_login_of_CeTask_if_submitter_exists() {
+ UserDto userDto = insertUser(UserTesting.newUserDto());
+ CeTaskSubmit taskSubmit = createTaskSubmit(CeTaskTypes.REPORT, null, userDto.getUuid());
+
+ CeTask task = underTest.submit(taskSubmit);
+
+ verifyCeTask(taskSubmit, task, null, userDto);
}
@Test
String mainComponentUuid = randomAlphabetic(10);
CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, newComponent(mainComponentUuid), "submitter uuid");
CeTaskSubmit taskSubmit2 = createTaskSubmit("some type");
+ UserDto userDto1 = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit1.getSubmitterUuid());
+
List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2));
assertThat(tasks).hasSize(2);
- verifyCeTask(taskSubmit1, tasks.get(0), null);
- verifyCeTask(taskSubmit2, tasks.get(1), null);
+ verifyCeTask(taskSubmit1, tasks.get(0), null, userDto1);
+ verifyCeTask(taskSubmit2, tasks.get(1), null, null);
verifyCeQueueDtoForTaskSubmit(taskSubmit1);
verifyCeQueueDtoForTaskSubmit(taskSubmit2);
}
List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2));
assertThat(tasks).hasSize(2);
- verifyCeTask(taskSubmit1, tasks.get(0), componentDto1);
- verifyCeTask(taskSubmit2, tasks.get(1), null);
+ verifyCeTask(taskSubmit1, tasks.get(0), componentDto1, null);
+ verifyCeTask(taskSubmit2, tasks.get(1), null, null);
}
@Test
List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2));
assertThat(tasks).hasSize(2);
- verifyCeTask(taskSubmit1, tasks.get(0), branch1, project);
- verifyCeTask(taskSubmit2, tasks.get(1), branch2, project);
+ verifyCeTask(taskSubmit1, tasks.get(0), branch1, project, null);
+ verifyCeTask(taskSubmit2, tasks.get(1), branch2, project, null);
}
@Test
assertThat(underTest.getWorkersPauseStatus()).isEqualTo(CeQueue.WorkersPauseStatus.RESUMED);
}
- private void verifyCeTask(CeTaskSubmit taskSubmit, CeTask task, @Nullable ComponentDto componentDto) {
- verifyCeTask(taskSubmit, task, componentDto, componentDto);
+
+ private void verifyCeTask(CeTaskSubmit taskSubmit, CeTask task, @Nullable ComponentDto componentDto, UserDto userDto) {
+ verifyCeTask(taskSubmit, task, componentDto, componentDto, userDto);
}
- private void verifyCeTask(CeTaskSubmit taskSubmit, CeTask task, @Nullable ComponentDto componentDto, @Nullable ComponentDto mainComponentDto) {
+ private void verifyCeTask(CeTaskSubmit taskSubmit, CeTask task, @Nullable ComponentDto componentDto, @Nullable ComponentDto mainComponentDto, @Nullable UserDto userDto) {
if (componentDto == null) {
assertThat(task.getOrganizationUuid()).isEqualTo(defaultOrganizationProvider.get().getUuid());
} else {
assertThat(task.getMainComponent()).isEmpty();
}
assertThat(task.getType()).isEqualTo(taskSubmit.getType());
- assertThat(task.getSubmitterUuid()).isEqualTo(taskSubmit.getSubmitterUuid());
+ if (taskSubmit.getSubmitterUuid() != null) {
+ if (userDto == null) {
+ assertThat(task.getSubmitter().getUuid()).isEqualTo(taskSubmit.getSubmitterUuid());
+ assertThat(task.getSubmitter().getLogin()).isNull();
+ } else {
+ assertThat(task.getSubmitter().getUuid()).isEqualTo(userDto.getUuid()).isEqualTo(taskSubmit.getSubmitterUuid());
+ assertThat(task.getSubmitter().getLogin()).isEqualTo(userDto.getLogin());
+ }
+ }
}
private void verifyCeQueueDtoForTaskSubmit(CeTaskSubmit taskSubmit) {
return componentDto;
}
+ private UserDto insertUser(UserDto userDto) {
+ db.getDbClient().userDao().insert(session, userDto);
+ session.commit();
+ return userDto;
+ }
+
private CeQueueDto insertPendingInQueue(@Nullable Component component) {
CeQueueDto dto = new CeQueueDto()
.setUuid(UuidFactoryFast.getInstance().create())
private final String uuid;
private final Component component;
private final Component mainComponent;
- private final String submitterUuid;
+ private final User submitter;
private final Map<String, String> characteristics;
private CeTask(Builder builder) {
"None or both component and main component must be non null");
this.component = builder.component;
this.mainComponent = builder.mainComponent;
- this.submitterUuid = emptyToNull(builder.submitterUuid);
+ this.submitter = builder.submitter;
if (builder.characteristics == null) {
this.characteristics = emptyMap();
} else {
}
}
+ @Immutable
+ public static final class User {
+ private final String uuid;
+ private final String login;
+
+ public User(String uuid, @Nullable String login) {
+ this.uuid = requireNonNull(uuid);
+ this.login = emptyToNull(login);
+ }
+
+ public String getUuid() {
+ return uuid;
+ }
+
+ @CheckForNull
+ public String getLogin() {
+ return login;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ User other = (User) o;
+ return uuid.equals(other.uuid);
+ }
+
+ @Override
+ public String toString() {
+ return "User{" +
+ "uuid='" + uuid + '\'' +
+ ", login='" + login + '\'' +
+ '}';
+ }
+
+ @Override
+ public int hashCode() {
+ return uuid.hashCode();
+ }
+ }
+
public String getOrganizationUuid() {
return organizationUuid;
}
}
@CheckForNull
- public String getSubmitterUuid() {
- return submitterUuid;
+ public User getSubmitter() {
+ return submitter;
}
public Map<String, String> getCharacteristics() {
.add("uuid", uuid)
.add("component", component)
.add("mainComponent", mainComponent)
- .add("submitterUuid", submitterUuid)
+ .add("submitter", submitter)
.toString();
}
private String type;
private Component component;
private Component mainComponent;
- private String submitterUuid;
+ private User submitter;
private Map<String, String> characteristics;
public Builder setOrganizationUuid(String organizationUuid) {
return this;
}
- public Builder setSubmitterUuid(@Nullable String s) {
- this.submitterUuid = s;
+ public Builder setSubmitter(@Nullable User s) {
+ this.submitter = s;
return this;
}
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("None or both component and main component must be non null");
-
+
underTest.build();
}
public void verify_getters() {
CeTask.Component component = new CeTask.Component("COMPONENT_UUID_1", "COMPONENT_KEY_1", "The component");
CeTask.Component mainComponent = new CeTask.Component("MAIN_COMPONENT_UUID_1", "MAIN_COMPONENT_KEY_1", "The main component");
+ CeTask.User submitter = new CeTask.User("UUID_USER_1", "LOGIN_1");
underTest.setOrganizationUuid("org1");
underTest.setType("TYPE_1");
underTest.setUuid("UUID_1");
- underTest.setSubmitterUuid("LOGIN_1");
+ underTest.setSubmitter(submitter);
underTest.setComponent(component);
underTest.setMainComponent(mainComponent);
underTest.setCharacteristics(ImmutableMap.of("k1", "v1", "k2", "v2"));
assertThat(task.getOrganizationUuid()).isEqualTo("org1");
assertThat(task.getUuid()).isEqualTo("UUID_1");
assertThat(task.getType()).isEqualTo("TYPE_1");
- assertThat(task.getSubmitterUuid()).isEqualTo("LOGIN_1");
+ assertThat(task.getSubmitter()).isEqualTo(submitter);
assertThat(task.getComponent()).contains(component);
assertThat(task.getMainComponent()).contains(mainComponent);
assertThat(task.getCharacteristics()).containsExactly(entry("k1", "v1"), entry("k2", "v2"));
}
+ @Test
+ public void verify_toString() {
+ CeTask.Component component = new CeTask.Component("COMPONENT_UUID_1", "COMPONENT_KEY_1", "The component");
+ CeTask.Component mainComponent = new CeTask.Component("MAIN_COMPONENT_UUID_1", "MAIN_COMPONENT_KEY_1", "The main component");
+ underTest.setOrganizationUuid("org1");
+ underTest.setType("TYPE_1");
+ underTest.setUuid("UUID_1");
+ underTest.setComponent(component);
+ underTest.setMainComponent(mainComponent);
+ underTest.setSubmitter(new CeTask.User("UUID_USER_1", "LOGIN_1"));
+ underTest.setCharacteristics(ImmutableMap.of("k1", "v1", "k2", "v2"));
+
+ CeTask task = underTest.build();
+ System.out.println(task.toString());
+
+ assertThat(task.toString()).isEqualTo("CeTask{" +
+ "organizationUuid=org1, " +
+ "type=TYPE_1, " +
+ "uuid=UUID_1, " +
+ "component=Component{uuid='COMPONENT_UUID_1', key='COMPONENT_KEY_1', name='The component'}, " +
+ "mainComponent=Component{uuid='MAIN_COMPONENT_UUID_1', key='MAIN_COMPONENT_KEY_1', name='The main component'}, " +
+ "submitter=User{uuid='UUID_USER_1', login='LOGIN_1'}" +
+ "}"
+ );
+ }
+
@Test
public void empty_in_submitterLogin_is_considered_as_null() {
CeTask ceTask = underTest.setOrganizationUuid("org1").setUuid("uuid").setType("type")
- .setSubmitterUuid("")
+ .setSubmitter(new CeTask.User("USER_ID", ""))
.build();
- assertThat(ceTask.getSubmitterUuid()).isNull();
+ assertThat(ceTask.getSubmitter().getLogin()).isNull();
}
@Test
.build();
assertThat(task.getCharacteristics()).isEmpty();
}
+
+ @Test
+ public void verify_submitter_getters() {
+ CeTask.User user = new CeTask.User("UUID", "LOGIN");
+
+ assertThat(user.getUuid()).isEqualTo("UUID");
+ assertThat(user.getLogin()).isEqualTo("LOGIN");
+ }
+
+ @Test
+ public void submitter_equals_and_hashCode_on_uuid() {
+ CeTask.User user1 = new CeTask.User("UUID_1", null);
+ CeTask.User user1bis = new CeTask.User("UUID_1", null);
+ CeTask.User user2 = new CeTask.User("UUID_2", null);
+ CeTask.User user1_diff_login = new CeTask.User("UUID_1", "LOGIN");
+
+ assertThat(user1).isEqualTo(user1);
+ assertThat(user1).isEqualTo(user1bis);
+ assertThat(user1).isNotEqualTo(user2);
+ assertThat(user1.equals(null)).isFalse();
+ assertThat(user1.hashCode()).isEqualTo(user1.hashCode());
+ assertThat(user1.hashCode()).isEqualTo(user1bis.hashCode());
+ assertThat(user1.hashCode()).isEqualTo(user1_diff_login.hashCode());
+ }
}
Map<String, String> characteristics = dbClient.ceTaskCharacteristicsDao().selectByTaskUuids(dbSession, singletonList(taskDto.getUuid())).stream()
.collect(uniqueIndex(CeTaskCharacteristicDto::getKey, CeTaskCharacteristicDto::getValue));
- CeTask task = convertToTask(taskDto, characteristics,
+ CeTask task = convertToTask(dbSession, taskDto, characteristics,
ofNullable(taskDto.getComponentUuid()).map(componentsByUuid::get).orElse(null),
ofNullable(taskDto.getMainComponentUuid()).map(componentsByUuid::get).orElse(null));
queueStatus.addInProgress();
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Supplier;
+import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.utils.MessageException;
import org.sonar.api.utils.log.Logger;
}
return profiler
.addContext("id", task.getUuid())
- .addContext("submitter", task.getSubmitterUuid())
+ .addContext("submitter", submitterOf(task))
.startInfo("Execute task");
}
+ @CheckForNull
+ private static String submitterOf(CeTask task) {
+ CeTask.User submitter = task.getSubmitter();
+ if (submitter == null) {
+ return null;
+ }
+ String submitterLogin = submitter.getLogin();
+ if (submitterLogin != null) {
+ return submitterLogin;
+ } else {
+ return submitter.getUuid();
+ }
+ }
+
private static void stopLogProfiler(Profiler profiler, CeActivityDto.Status status) {
profiler.addContext("status", status.name());
profiler.stopInfo("Executed task");
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.ComponentTesting;
import org.sonar.db.organization.OrganizationDto;
+import org.sonar.db.user.UserDto;
import org.sonar.server.organization.DefaultOrganization;
import org.sonar.server.organization.DefaultOrganizationProvider;
public void submit_returns_task_populated_from_CeTaskSubmit_and_creates_CeQueue_row() {
CeTaskSubmit taskSubmit = createTaskSubmit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1"), "rob");
CeTask task = underTest.submit(taskSubmit);
-
- verifyCeTask(taskSubmit, task, null);
+ UserDto userDto = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit.getSubmitterUuid());
+ verifyCeTask(taskSubmit, task, null, userDto);
verifyCeQueueDtoForTaskSubmit(taskSubmit);
}
CeTask task = underTest.submit(taskSubmit);
- verifyCeTask(taskSubmit, task, componentDto);
+ verifyCeTask(taskSubmit, task, componentDto, null);
}
@Test
CeTask task = underTest.submit(taskSubmit);
- verifyCeTask(taskSubmit, task, null);
+ verifyCeTask(taskSubmit, task, null, null);
}
@Test
List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2));
+ UserDto userDto1 = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit1.getSubmitterUuid());
assertThat(tasks).hasSize(2);
- verifyCeTask(taskSubmit1, tasks.get(0), null);
- verifyCeTask(taskSubmit2, tasks.get(1), null);
+ verifyCeTask(taskSubmit1, tasks.get(0), null, userDto1);
+ verifyCeTask(taskSubmit2, tasks.get(1), null, null);
verifyCeQueueDtoForTaskSubmit(taskSubmit1);
verifyCeQueueDtoForTaskSubmit(taskSubmit2);
}
List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2));
assertThat(tasks).hasSize(2);
- verifyCeTask(taskSubmit1, tasks.get(0), componentDto1);
- verifyCeTask(taskSubmit2, tasks.get(1), null);
+ verifyCeTask(taskSubmit1, tasks.get(0), componentDto1, null);
+ verifyCeTask(taskSubmit2, tasks.get(1), null, null);
}
@Test
return dto;
}
- private void verifyCeTask(CeTaskSubmit taskSubmit, CeTask task, @Nullable ComponentDto componentDto) {
+ private void verifyCeTask(CeTaskSubmit taskSubmit, CeTask task, @Nullable ComponentDto componentDto, @Nullable UserDto userDto) {
if (componentDto == null) {
assertThat(task.getOrganizationUuid()).isEqualTo(defaultOrganizationProvider.get().getUuid());
} else {
} else {
assertThat(task.getComponent()).isEmpty();
}
- assertThat(task.getSubmitterUuid()).isEqualTo(taskSubmit.getSubmitterUuid());
+ if (taskSubmit.getSubmitterUuid() != null) {
+ if (userDto == null) {
+ assertThat(task.getSubmitter().getUuid()).isEqualTo(taskSubmit.getSubmitterUuid());
+ assertThat(task.getSubmitter().getLogin()).isNull();
+ } else {
+ assertThat(task.getSubmitter().getUuid()).isEqualTo(userDto.getUuid()).isEqualTo(taskSubmit.getSubmitterUuid());
+ assertThat(task.getSubmitter().getUuid()).isEqualTo(userDto.getLogin());
+ }
+ }
}
private void verifyCeQueueDtoForTaskSubmit(CeTaskSubmit taskSubmit) {
import java.util.Optional;
import java.util.Random;
import java.util.UUID;
+import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.apache.commons.lang.RandomStringUtils;
import org.junit.Before;
import org.mockito.InOrder;
import org.mockito.Mockito;
import org.sonar.api.utils.MessageException;
+import org.sonar.api.utils.System2;
+import org.sonar.api.utils.internal.TestSystem2;
import org.sonar.api.utils.log.LogAndArguments;
import org.sonar.api.utils.log.LogTester;
import org.sonar.api.utils.log.LoggerLevel;
import org.sonar.ce.queue.InternalCeQueue;
import org.sonar.ce.task.CeTask;
+import org.sonar.ce.task.CeTaskResult;
import org.sonar.ce.task.projectanalysis.taskprocessor.ReportTaskProcessor;
+import org.sonar.db.DbSession;
+import org.sonar.db.DbTester;
import org.sonar.db.ce.CeActivityDto;
import org.sonar.db.ce.CeTaskTypes;
+import org.sonar.db.user.UserDto;
+import org.sonar.db.user.UserTesting;
import org.sonar.server.organization.BillingValidations;
import static org.assertj.core.api.Assertions.assertThat;
public class CeWorkerImplTest {
+ private System2 system2 = new TestSystem2().setNow(1_450_000_000_000L);
+
@Rule
public CeTaskProcessorRepositoryRule taskProcessorRepository = new CeTaskProcessorRepositoryRule();
@Rule
public LogTester logTester = new LogTester();
@Rule
public ExpectedException expectedException = ExpectedException.none();
+ @Rule
+ public DbTester db = DbTester.create(system2);
+
+ private DbSession session = db.getSession();
private InternalCeQueue queue = mock(InternalCeQueue.class);
private ReportTaskProcessor taskProcessor = mock(ReportTaskProcessor.class);
executionListener1, executionListener2);
private CeWorker underTestNoListener = new CeWorkerImpl(randomOrdinal, workerUuid, queue, taskProcessorRepository, enabledCeWorkerController);
private InOrder inOrder = Mockito.inOrder(taskProcessor, queue, executionListener1, executionListener2);
+ private final CeTask.User submitter = new CeTask.User("UUID_USER_1", "LOGIN_1");
@Before
public void setUp() {
@Test
public void log_submitter_login_if_authenticated_and_success() throws Exception {
- when(queue.peek(anyString())).thenReturn(Optional.of(createCeTask("FooBar")));
+ UserDto userDto = insertRandomUser();
+ when(queue.peek(anyString())).thenReturn(Optional.of(createCeTask(toTaskSubmitter(userDto))));
+ taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
+
+ underTest.call();
+
+ verifyWorkerUuid();
+ List<String> logs = logTester.logs(LoggerLevel.INFO);
+ assertThat(logs).hasSize(2);
+ assertThat(logs.get(0)).contains(String.format("submitter=%s", userDto.getLogin()));
+ assertThat(logs.get(1)).contains(String.format("submitter=%s | status=SUCCESS | time=", userDto.getLogin()));
+ assertThat(logTester.logs(LoggerLevel.ERROR)).isEmpty();
+ assertThat(logTester.logs(LoggerLevel.DEBUG)).isEmpty();
+ }
+
+ @Test
+ public void log_submitterUuid_if_user_matching_submitterUuid_can_not_be_found() throws Exception {
+ when(queue.peek(anyString())).thenReturn(Optional.of(createCeTask(new CeTask.User("UUID_USER", null))));
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
underTest.call();
verifyWorkerUuid();
List<String> logs = logTester.logs(LoggerLevel.INFO);
assertThat(logs).hasSize(2);
- assertThat(logs.get(0)).contains("submitter=FooBar");
- assertThat(logs.get(1)).contains("submitter=FooBar | status=SUCCESS | time=");
+ assertThat(logs.get(0)).contains("submitter=UUID_USER");
+ assertThat(logs.get(1)).contains("submitter=UUID_USER | status=SUCCESS | time=");
assertThat(logTester.logs(LoggerLevel.ERROR)).isEmpty();
assertThat(logTester.logs(LoggerLevel.DEBUG)).isEmpty();
}
@Test
public void display_submitterLogin_in_logs_when_set_in_case_of_error() throws Exception {
- CeTask ceTask = createCeTask("FooBar");
+ UserDto userDto = insertRandomUser();
+ CeTask ceTask = createCeTask(toTaskSubmitter(userDto));
when(queue.peek(anyString())).thenReturn(Optional.of(ceTask));
taskProcessorRepository.setProcessorForTask(ceTask.getType(), taskProcessor);
makeTaskProcessorFail(ceTask);
verifyWorkerUuid();
List<String> logs = logTester.logs(LoggerLevel.INFO);
assertThat(logs).hasSize(2);
- assertThat(logs.get(0)).contains(" | submitter=FooBar");
- assertThat(logs.get(1)).contains(" | submitter=FooBar | status=FAILED | time=");
+ assertThat(logs.get(0)).contains(String.format("submitter=%s", userDto.getLogin()));
+ assertThat(logs.get(1)).contains(String.format("submitter=%s | status=FAILED | time=", userDto.getLogin()));
logs = logTester.logs(LoggerLevel.ERROR);
assertThat(logs).hasSize(1);
assertThat(logs.get(0)).isEqualTo("Failed to execute task " + ceTask.getUuid());
public void display_start_stop_at_debug_level_for_console_if_DEBUG_is_enabled_and_task_successful() throws Exception {
logTester.setLevel(LoggerLevel.DEBUG);
- when(queue.peek(anyString())).thenReturn(Optional.of(createCeTask("FooBar")));
+ when(queue.peek(anyString())).thenReturn(Optional.of(createCeTask(submitter)));
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
underTest.call();
verifyWorkerUuid();
List<String> logs = logTester.logs(LoggerLevel.INFO);
assertThat(logs).hasSize(2);
- assertThat(logs.get(0)).contains(" | submitter=FooBar");
- assertThat(logs.get(1)).contains(" | submitter=FooBar | status=SUCCESS | time=");
+ assertThat(logs.get(0)).contains(" | submitter=" + submitter.getLogin());
+ assertThat(logs.get(1)).contains(String.format(" | submitter=%s | status=SUCCESS | time=", submitter.getLogin()));
assertThat(logTester.logs(LoggerLevel.ERROR)).isEmpty();
assertThat(logTester.logs(LoggerLevel.DEBUG)).isEmpty();
}
public void display_start_at_debug_level_stop_at_error_level_for_console_if_DEBUG_is_enabled_and_task_failed() throws Exception {
logTester.setLevel(LoggerLevel.DEBUG);
- CeTask ceTask = createCeTask("FooBar");
+ CeTask ceTask = createCeTask(submitter);
when(queue.peek(anyString())).thenReturn(Optional.of(ceTask));
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
makeTaskProcessorFail(ceTask);
verifyWorkerUuid();
List<String> logs = logTester.logs(LoggerLevel.INFO);
assertThat(logs).hasSize(2);
- assertThat(logs.get(0)).contains(" | submitter=FooBar");
- assertThat(logs.get(1)).contains(" | submitter=FooBar | status=FAILED | time=");
+ assertThat(logs.get(0)).contains(" | submitter=" + submitter.getLogin());
+ assertThat(logs.get(1)).contains(String.format(" | submitter=%s | status=FAILED | time=", submitter.getLogin()));
logs = logTester.logs(LoggerLevel.ERROR);
assertThat(logs).hasSize(1);
assertThat(logs.iterator().next()).isEqualTo("Failed to execute task " + ceTask.getUuid());
when(queue.peek(anyString())).thenAnswer(invocation -> {
assertThat(Thread.currentThread().getName())
.isEqualTo("Worker " + randomOrdinal + " (UUID=" + workerUuid + ") on " + threadName);
- return Optional.of(createCeTask("FooBar"));
+ return Optional.of(createCeTask(submitter));
});
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
Thread newThread = createThreadNameVerifyingThread(threadName);
@Test
public void call_sets_and_restores_thread_name_with_information_of_worker_when_an_error_occurs() throws Exception {
String threadName = RandomStringUtils.randomAlphabetic(3);
- CeTask ceTask = createCeTask("FooBar");
+ CeTask ceTask = createCeTask(submitter);
when(queue.peek(anyString())).thenAnswer(invocation -> {
assertThat(Thread.currentThread().getName())
.isEqualTo("Worker " + randomOrdinal + " (UUID=" + workerUuid + ") on " + threadName);
@Test
public void log_error_when_task_fails_with_not_MessageException() throws Exception {
- CeTask ceTask = createCeTask("FooBar");
+ CeTask ceTask = createCeTask(submitter);
when(queue.peek(anyString())).thenReturn(Optional.of(ceTask));
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
makeTaskProcessorFail(ceTask);
List<String> logs = logTester.logs(LoggerLevel.INFO);
assertThat(logs).hasSize(2);
- assertThat(logs.get(0)).contains(" | submitter=FooBar");
- assertThat(logs.get(1)).contains(" | submitter=FooBar | status=FAILED | time=");
+ assertThat(logs.get(0)).contains(" | submitter=" + submitter.getLogin());
+ assertThat(logs.get(1)).contains(String.format(" | submitter=%s | status=FAILED | time=", submitter.getLogin()));
logs = logTester.logs(LoggerLevel.ERROR);
assertThat(logs).hasSize(1);
assertThat(logs.iterator().next()).isEqualTo("Failed to execute task " + ceTask.getUuid());
@Test
public void do_no_log_error_when_task_fails_with_MessageException() throws Exception {
- CeTask ceTask = createCeTask("FooBar");
+ CeTask ceTask = createCeTask(submitter);
when(queue.peek(anyString())).thenReturn(Optional.of(ceTask));
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
makeTaskProcessorFail(ceTask, MessageException.of("simulate MessageException thrown by TaskProcessor#process"));
List<String> logs = logTester.logs(LoggerLevel.INFO);
assertThat(logs).hasSize(2);
- assertThat(logs.get(1)).contains(" | submitter=FooBar");
- assertThat(logs.get(1)).contains(" | submitter=FooBar | status=FAILED | time=");
+ assertThat(logs.get(1)).contains(" | submitter=" + submitter.getLogin());
+ assertThat(logs.get(1)).contains(String.format(" | submitter=%s | status=FAILED | time=", submitter.getLogin()));
assertThat(logTester.logs(LoggerLevel.ERROR)).isEmpty();
}
@Test
public void do_no_log_error_when_task_fails_with_BillingValidationsException() throws Exception {
- CeTask ceTask = createCeTask("FooBar");
+ CeTask ceTask = createCeTask(submitter);
when(queue.peek(anyString())).thenReturn(Optional.of(ceTask));
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
makeTaskProcessorFail(ceTask, new BillingValidations.BillingValidationsException("simulate MessageException thrown by TaskProcessor#process"));
List<String> logs = logTester.logs(LoggerLevel.INFO);
assertThat(logs).hasSize(2);
- assertThat(logs.get(1)).contains(" | submitter=FooBar");
- assertThat(logs.get(1)).contains(" | submitter=FooBar | status=FAILED | time=");
+ assertThat(logs.get(1)).contains(" | submitter=" + submitter.getLogin());
+ assertThat(logs.get(1)).contains(String.format(" | submitter=%s | status=FAILED | time=", submitter.getLogin()));
assertThat(logTester.logs(LoggerLevel.ERROR)).isEmpty();
}
@Test
public void log_error_when_task_was_successful_but_ending_state_can_not_be_persisted_to_db() throws Exception {
- CeTask ceTask = createCeTask("FooBar");
+ CeTask ceTask = createCeTask(submitter);
when(queue.peek(anyString())).thenReturn(Optional.of(ceTask));
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
doThrow(new RuntimeException("Simulate queue#remove failing")).when(queue).remove(ceTask, CeActivityDto.Status.SUCCESS, null, null);
@Test
public void log_error_when_task_failed_and_ending_state_can_not_be_persisted_to_db() throws Exception {
- CeTask ceTask = createCeTask("FooBar");
+ CeTask ceTask = createCeTask(submitter);
when(queue.peek(anyString())).thenReturn(Optional.of(ceTask));
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
IllegalStateException ex = makeTaskProcessorFail(ceTask);
List<String> logs = logTester.logs(LoggerLevel.INFO);
assertThat(logs).hasSize(2);
- assertThat(logs.get(0)).contains(" | submitter=FooBar");
- assertThat(logs.get(1)).contains(" | submitter=FooBar | status=FAILED | time=");
+ assertThat(logs.get(0)).contains(" | submitter=" + submitter.getLogin());
+ assertThat(logs.get(1)).contains(String.format(" | submitter=%s | status=FAILED | time=", submitter.getLogin()));
List<LogAndArguments> logAndArguments = logTester.getLogs(LoggerLevel.ERROR);
assertThat(logAndArguments).hasSize(2);
@Test
public void log_error_as_suppressed_when_task_failed_with_MessageException_and_ending_state_can_not_be_persisted_to_db() throws Exception {
- CeTask ceTask = createCeTask("FooBar");
+ CeTask ceTask = createCeTask(submitter);
when(queue.peek(anyString())).thenReturn(Optional.of(ceTask));
taskProcessorRepository.setProcessorForTask(CeTaskTypes.REPORT, taskProcessor);
MessageException ex = makeTaskProcessorFail(ceTask, MessageException.of("simulate MessageException thrown by TaskProcessor#process"));
List<String> logs = logTester.logs(LoggerLevel.INFO);
assertThat(logs).hasSize(2);
- assertThat(logs.get(0)).contains(" | submitter=FooBar");
- assertThat(logs.get(1)).contains(" | submitter=FooBar | status=FAILED | time=");
+ assertThat(logs.get(0)).contains(" | submitter=" + submitter.getLogin());
+ assertThat(logs.get(1)).contains(String.format(" | submitter=%s | status=FAILED | time=", submitter.getLogin()));
List<LogAndArguments> logAndArguments = logTester.getLogs(LoggerLevel.ERROR);
assertThat(logAndArguments).hasSize(1);
assertThat(logAndArguments.get(0).getFormattedMsg()).isEqualTo("Failed to finalize task with uuid '" + ceTask.getUuid() + "' and persist its state to db");
assertThat(workerUuidCaptor.getValue()).isEqualTo(workerUuid);
}
- private static CeTask createCeTask(@Nullable String submitterLogin, String... characteristics) {
+ private static CeTask createCeTask(@Nullable CeTask.User submitter, String... characteristics) {
Map<String, String> characteristicMap = new HashMap<>();
for (int i = 0; i < characteristics.length; i += 2) {
characteristicMap.put(characteristics[i], characteristics[i + 1]);
.setUuid("TASK_1").setType(CeTaskTypes.REPORT)
.setComponent(component)
.setMainComponent(component)
- .setSubmitterUuid(submitterLogin)
+ .setSubmitter(submitter)
.setCharacteristics(characteristicMap)
.build();
}
+
+ private UserDto insertRandomUser() {
+ UserDto userDto = UserTesting.newUserDto();
+ db.getDbClient().userDao().insert(session, userDto);
+ session.commit();
+ return userDto;
+ }
+
+ private CeTask.User toTaskSubmitter(UserDto userDto) {
+ return new CeTask.User(userDto.getUuid(), userDto.getLogin());
+ }
private IllegalStateException makeTaskProcessorFail(CeTask task) {
return makeTaskProcessorFail(task, new IllegalStateException("simulate exception thrown by TaskProcessor#process"));
.setType(CeTaskTypes.REPORT)
.setComponent(COMPONENT)
.setMainComponent(COMPONENT)
- .setSubmitterUuid("robert")
+ .setSubmitter(new CeTask.User("UUID_1", "LOGIN_1"))
.build();
@Captor
projects / sonarqube.git / commitdiff