@Override @CheckForNull public String getUuid() { return userDto == null ? null : userDto.getUuid(); }
private SearchWsResponse buildResponse(List<UserDto> users, Multimap<String, String> groupsByLogin, Map<String, Integer> tokenCountsByLogin, @Nullable List<String> fields, Paging paging) { SearchWsResponse.Builder responseBuilder = newBuilder(); users.forEach(user -> responseBuilder.addUsers(towsUser(user, firstNonNull(tokenCountsByLogin.get(user.getUuid()), 0), groupsByLogin.get(user.getLogin()), fields))); responseBuilder.getPagingBuilder() .setPageIndex(paging.pageIndex()) .setPageSize(paging.pageSize()) .setTotal(paging.total()) .build(); return responseBuilder.build(); }
@Test public void validate_token() { UserDto user = db.users().insertUser(); addJwtCookie(); Claims claims = createToken(user.getUuid(), NOW); when(jwtSerializer.decode(JWT_TOKEN)).thenReturn(Optional.of(claims)); assertThat(underTest.validateToken(request, response).isPresent()).isTrue(); verify(jwtSerializer, never()).encode(any(JwtSerializer.JwtSession.class)); }
@Test public void authenticate_from_user_token() { UserDto user = db.users().insertUser(); when(userTokenAuthentication.authenticate("token")).thenReturn(Optional.of(user.getUuid())); when(request.getHeader("Authorization")).thenReturn("Basic " + toBase64("token:")); Optional<UserDto> userAuthenticated = underTest.authenticate(request); assertThat(userAuthenticated.isPresent()).isTrue(); assertThat(userAuthenticated.get().getLogin()).isEqualTo(user.getLogin()); verify(authenticationEvent).loginSuccess(request, user.getLogin(), Source.local(BASIC_TOKEN)); }
@Test public void selectUsersByUuids() { UserDto user1 = db.users().insertUser(); UserDto user2 = db.users().insertUser(); UserDto user3 = db.users().insertUser(user -> user.setActive(false)); assertThat((Collection<UserDto>) underTest.selectByUuids(session, asList(user1.getUuid(), user2.getUuid(), user3.getUuid()))).hasSize(3); assertThat((Collection<UserDto>) underTest.selectByUuids(session, asList(user1.getUuid(), "unknown"))).hasSize(1); assertThat((Collection<UserDto>) underTest.selectByUuids(session, Collections.emptyList())).isEmpty(); }
@Test public void assign_issue() { UserDto assignee = db.users().insertUser("john"); db.organizations().addMember(issueOrganizationDto, assignee); Map<String, Object> properties = new HashMap<>(ImmutableMap.of("assignee", "john")); underTest.verify(properties, Collections.emptyList(), userSession); boolean executeResult = underTest.execute(properties, context); assertThat(executeResult).isTrue(); assertThat(issue.assignee()).isEqualTo(assignee.getUuid()); }
@Test public void default_assignee_is_cached() { settings.setProperty(CoreProperties.DEFAULT_ISSUE_ASSIGNEE, "erik"); UserDto userDto = db.users().insertUser("erik"); db.organizations().addMember(organizationDto, userDto); assertThat(underTest.loadDefaultAssigneeUuid()).isEqualTo(userDto.getUuid()); // The setting is updated but the assignee hasn't changed settings.setProperty(CoreProperties.DEFAULT_ISSUE_ASSIGNEE, "other"); assertThat(underTest.loadDefaultAssigneeUuid()).isEqualTo(userDto.getUuid()); } }
@Test public void selectByUuid() { UserDto user1 = db.users().insertUser(); UserDto user2 = db.users().insertUser(user -> user.setActive(false)); assertThat(underTest.selectByUuid(session, user1.getUuid())).isNotNull(); assertThat(underTest.selectByUuid(session, user2.getUuid())).isNotNull(); assertThat(underTest.selectByUuid(session, "unknown")).isNull(); }
@Test public void validate_token_does_not_refresh_session_when_disconnected_timeout_is_reached() { UserDto user = db.users().insertUser(); addJwtCookie(); // Token was created 4 months ago, refreshed 4 minutes ago, and it expired in 5 minutes Claims claims = createToken(user.getUuid(), NOW - (4L * 30 * 24 * 60 * 60 * 1000)); claims.setExpiration(new Date(NOW + 5 * 60 * 1000)); claims.put("lastRefreshTime", FOUR_MINUTES_AGO); when(jwtSerializer.decode(JWT_TOKEN)).thenReturn(Optional.of(claims)); assertThat(underTest.validateToken(request, response).isPresent()).isFalse(); }
@Test public void assign() { UserDto user = newUserDto().setLogin("emmerik").setName("Emmerik"); boolean updated = underTest.assign(issue, user, context); assertThat(updated).isTrue(); assertThat(issue.assignee()).isEqualTo(user.getUuid()); assertThat(issue.mustSendNotifications()).isTrue(); FieldDiffs.Diff diff = issue.currentChange().get(ASSIGNEE); assertThat(diff.oldValue()).isEqualTo(UNUSED); assertThat(diff.newValue()).isEqualTo(user.getName()); }
@SafeVarargs public final UserTokenDto insertToken(UserDto user, Consumer<UserTokenDto>... populators) { UserTokenDto dto = newUserToken().setUserUuid(user.getUuid()); stream(populators).forEach(p -> p.accept(dto)); db.getDbClient().userTokenDao().insert(db.getSession(), dto); db.commit(); return dto; }
@Test public void change_assignee() { UserDto user = newUserDto().setLogin("emmerik").setName("Emmerik"); issue.setAssigneeUuid("user_uuid"); boolean updated = underTest.assign(issue, user, context); assertThat(updated).isTrue(); assertThat(issue.assignee()).isEqualTo(user.getUuid()); assertThat(issue.mustSendNotifications()).isTrue(); FieldDiffs.Diff diff = issue.currentChange().get(ASSIGNEE); assertThat(diff.oldValue()).isEqualTo(UNUSED); assertThat(diff.newValue()).isEqualTo(user.getName()); }
@Override public void handle(Request request, Response response) throws Exception { userSession.checkLoggedIn().checkIsSystemAdministrator(); UpdateRequest updateRequest = toWsRequest(request); checkArgument(isValidIfPresent(updateRequest.getEmail()), "Email '%s' is not valid", updateRequest.getEmail()); try (DbSession dbSession = dbClient.openSession(false)) { UserDto user = getUser(dbSession, updateRequest.getLogin()); doHandle(dbSession, updateRequest); writeUser(dbSession, response, user.getUuid()); } }
@Test public void does_not_authenticate_from_user_token_when_token_does_not_match_active_user() { UserDto user = db.users().insertDisabledUser(); when(userTokenAuthentication.authenticate("token")).thenReturn(Optional.of(user.getUuid())); when(request.getHeader("Authorization")).thenReturn("Basic " + toBase64("token:")); expectedException.expect(authenticationException().from(Source.local(Method.BASIC_TOKEN)).withoutLogin().andNoPublicMessage()); try { underTest.authenticate(request); } finally { verifyZeroInteractions(authenticationEvent); } }
@SafeVarargs public final CustomMeasureDto insertCustomMeasure(UserDto user, ComponentDto component, MetricDto metricDto, Consumer<CustomMeasureDto>... consumers) { Preconditions.checkArgument(metricDto.isUserManaged(),"Custom measure must be created from a custom metric"); CustomMeasureDto dto = newCustomMeasureDto().setUserUuid(user.getUuid()).setComponentUuid(component.uuid()).setMetricId(metricDto.getId()); Arrays.stream(consumers).forEach(c -> c.accept(dto)); dbClient.customMeasureDao().insert(dbSession, dto); dbSession.commit(); return dto; }
@Test public void commitAndIndex_single_user() { UserDto user = db.users().insertUser(); UserDto anotherUser = db.users().insertUser(); underTest.commitAndIndex(db.getSession(), user); List<UserDoc> docs = es.getDocuments(UserIndexDefinition.INDEX_TYPE_USER, UserDoc.class); assertThat(docs) .extracting(UserDoc::uuid) .containsExactlyInAnyOrder(user.getUuid()) .doesNotContain(anotherUser.getUuid()); }
@Test public void return_changelog_when_no_new_value() { UserDto user = insertUser(); IssueDto issueDto = db.issues().insertIssue(newIssue()); userSession.logIn("john") .addMembership(db.getDefaultOrganization()) .addProjectPermission(USER, project, file); db.issues().insertFieldDiffs(issueDto, new FieldDiffs().setUserUuid(user.getUuid()).setDiff("severity", "MAJOR", null).setCreationDate(new Date())); ChangelogWsResponse result = call(issueDto.getKey()); assertThat(result.getChangelogList()).hasSize(1); assertThat(result.getChangelogList().get(0).getDiffsList().get(0).hasNewValue()).isFalse(); }
@Test public void load_login_for_scm_account() { UserDto user = db.users().insertUser(u -> u.setScmAccounts(asList("charlie", "jesuis@charlie.com"))); OrganizationDto organization = db.organizations().insert(o -> o.setUuid(ORGANIZATION_UUID)); analysisMetadataHolder.setOrganization(Organization.from(organization)); db.organizations().addMember(organization, user); userIndexer.indexOnStartup(null); UserIndex index = new UserIndex(es.client(), System2.INSTANCE); ScmAccountToUserLoader underTest = new ScmAccountToUserLoader(index, analysisMetadataHolder); assertThat(underTest.load("missing")).isNull(); assertThat(underTest.load("jesuis@charlie.com")).isEqualTo(user.getUuid()); }
private DefaultIssue prepareIssue(long issueCreatedAt, UserDto user, ComponentDto project, ComponentDto file, RuleDefinitionDto ruleDefinitionDto, RuleType type) { DefaultIssue issue = newIssue(ruleDefinitionDto, project, file).setType(type).toDefaultIssue() .setNew(false).setChanged(true).setSendNotifications(true).setCreationDate(new Date(issueCreatedAt)).setAssigneeUuid(user.getUuid()); ruleRepository.add(ruleDefinitionDto.getKey()).setName(ruleDefinitionDto.getName()); issueCache.newAppender().append(issue).close(); when(notificationService.hasProjectSubscribersForTypes(PROJECT.getUuid(), NOTIF_TYPES)).thenReturn(true); return issue; }
public static UserPropertyDto newUserSettingDto(UserDto user) { return new UserPropertyDto() .setUuid(Uuids.createFast()) .setUserUuid(user.getUuid()) .setKey(randomAlphanumeric(20)) .setValue(randomAlphanumeric(100)); } }