private OrganizationDto insertOrganization(long createdAt) { when(system2.now()).thenReturn(createdAt); OrganizationDto dto = dbTester.organizations().insert(); dbTester.commit(); return dto; }
@Test public void deleteByUuids() { insertData(A_UUID); assertThat(dbTester.countRowsOfTable(TABLE_NAME)).isEqualTo(1); underTest.deleteByUuids(dbTester.getSession(), singleton(A_UUID)); dbTester.commit(); assertThat(dbTester.countRowsOfTable(TABLE_NAME)).isEqualTo(0); }
@SafeVarargs public final ComponentDto insertProjectBranch(ComponentDto project, Consumer<BranchDto>... dtoPopulators) { // MainBranchProjectUuid will be null if it's a main branch BranchDto branchDto = newBranchDto(firstNonNull(project.getMainBranchProjectUuid(), project.projectUuid()), LONG); Arrays.stream(dtoPopulators).forEach(dtoPopulator -> dtoPopulator.accept(branchDto)); ComponentDto branch = newProjectBranch(project, branchDto); insertComponent(branch); dbClient.branchDao().insert(dbSession, branchDto); db.commit(); return branch; }
@SafeVarargs public final QualityGateConditionDto addCondition(QualityGateDto qualityGate, MetricDto metric, Consumer<QualityGateConditionDto>... dtoPopulators) { QualityGateConditionDto condition = new QualityGateConditionDto().setQualityGateId(qualityGate.getId()) .setMetricId(metric.getId()) .setOperator("GT") .setErrorThreshold(randomNumeric(10)); Arrays.stream(dtoPopulators).forEach(dtoPopulator -> dtoPopulator.accept(condition)); dbClient.gateConditionDao().insert(condition, dbSession); db.commit(); return condition; } }
private UserPermissionDto addGlobalPermission(OrganizationDto org, String permission, UserDto user) { UserPermissionDto dto = new UserPermissionDto(org.getUuid(), permission, user.getId(), null); underTest.insert(dbSession, dto); db.commit(); return dto; }
public IssueChangeDto insertChange(IssueChangeDto issueChangeDto) { db.getDbClient().issueChangeDao().insert(db.getSession(), issueChangeDto); db.commit(); return issueChangeDto; }
public final ComponentDto insertProjectBranch(ComponentDto project, BranchDto branchDto) { // MainBranchProjectUuid will be null if it's a main branch checkArgument(branchDto.getProjectUuid().equals(firstNonNull(project.getMainBranchProjectUuid(), project.projectUuid()))); ComponentDto branch = newProjectBranch(project, branchDto); insertComponent(branch); dbClient.branchDao().insert(dbSession, branchDto); db.commit(); return branch; }
@Test public void peek_peeks_pending_task() { db.getDbClient().ceQueueDao().insert(session, new CeQueueDto() .setUuid("uuid") .setTaskType("foo") .setStatus(CeQueueDto.Status.PENDING)); db.commit(); assertThat(underTest.peek(WORKER_UUID_1).get().getUuid()).isEqualTo("uuid"); }
@Test public void testInsert() { dbTester.prepareDbUnit(getClass(), "insert.xml"); QualityGateConditionDto newCondition = new QualityGateConditionDto() .setQualityGateId(1L).setMetricId(2L).setOperator("GT").setErrorThreshold("20"); underTest.insert(newCondition, dbTester.getSession()); dbTester.commit(); dbTester.assertDbUnitTable(getClass(), "insert-result.xml", "quality_gate_conditions", "metric_id", "operator", "error_value"); assertThat(newCondition.getId()).isNotNull(); }
@Test public void delete_by_user_id() { underTest.insert(dbSession, create("O1", 512)); underTest.insert(dbSession, create("O1", 513)); underTest.insert(dbSession, create("O2", 512)); underTest.deleteByUserId(dbSession, 512); db.commit(); assertThat(db.select("select organization_uuid as \"organizationUuid\", user_id as \"userId\" from organization_members")) .extracting((row) -> row.get("organizationUuid"), (row) -> row.get("userId")) .containsOnly(tuple("O1", 513L)); }
@Test public void recovery_does_not_fail_if_unsupported_docIdType() { EsQueueDto item = EsQueueDto.create(INDEX_TYPE_ISSUE.format(), "I1", "unknown", "P1"); db.getDbClient().esQueueDao().insert(db.getSession(), item); db.commit(); recover(); assertThat(logTester.logs(LoggerLevel.ERROR)) .filteredOn(l -> l.contains("Unsupported es_queue.doc_id_type for issues. Manual fix is required: ")) .hasSize(1); assertThatEsQueueTableHasSize(1); }
private void unsafeInsertProjectPermissionOnUser(ComponentDto component, UserDto user, String permission) { UserPermissionDto dto = new UserPermissionDto(component.getOrganizationUuid(), permission, user.getId(), component.getId()); dbTester.getDbClient().userPermissionDao().insert(dbTester.getSession(), dto); dbTester.commit(); }
private CeQueueDto insertCeQueueDto(String uuid) { CeQueueDto dto = new CeQueueDto() .setUuid(uuid) .setTaskType("foo") .setStatus(CeQueueDto.Status.PENDING); db.getDbClient().ceQueueDao().insert(db.getSession(), dto); db.commit(); return dto; }
public OrganizationAlmBindingDto insertOrganizationAlmBinding(OrganizationDto organization, AlmAppInstallDto almAppInstall) { UserDto user = db.users().insertUser(); db.getDbClient().organizationAlmBindingDao().insert(db.getSession(), organization, almAppInstall, randomAlphabetic(10), user.getUuid()); db.commit(); return db.getDbClient().organizationAlmBindingDao().selectByOrganization(db.getSession(), organization).get(); }
@Before public void setUp() { persistedProfile = newRuleProfileDto(rp -> rp .setIsBuiltIn(true) .setLanguage("xoo") .setRulesUpdatedAt(null)); db.getDbClient().qualityProfileDao().insert(db.getSession(), persistedProfile); db.commit(); }
@Test public void create_2_version_events_on_same_project() { ComponentDto project = ComponentTesting.newPrivateProjectDto(db.organizations().insert()); SnapshotDto firstAnalysis = db.components().insertProjectAndSnapshot(project); SnapshotDto secondAnalysis = dbClient.snapshotDao().insert(dbSession, newAnalysis(project)); db.commit(); logInAsProjectAdministrator(project); call(VERSION.name(), "5.6.3", firstAnalysis.getUuid()); call(VERSION.name(), "6.3", secondAnalysis.getUuid()); List<EventDto> events = dbClient.eventDao().selectByComponentUuid(dbSession, project.uuid()); assertThat(events).hasSize(2); }
@Test public void fail_when_sort_is_unknown() { expectedException.expect(IllegalArgumentException.class); db.components().insertComponent(newPrivateProjectDto(db.getDefaultOrganization(), "project-uuid")); db.commit(); ws.newRequest() .setParam(PARAM_COMPONENT_ID, "project-uuid") .setParam(Param.SORT, "unknown-sort") .execute(); }
private void insertRulesProfile(BuiltInQProfile builtIn) { RulesProfileDto dto = new RulesProfileDto() .setIsBuiltIn(true) .setKee(RandomStringUtils.randomAlphabetic(40)) .setLanguage(builtIn.getLanguage()) .setName(builtIn.getName()); dbClient.qualityProfileDao().insert(db.getSession(), dto); db.commit(); }
private void unsafeInsertProjectPermissionOnAnyone(String perm, ComponentDto project) { GroupPermissionDto dto = new GroupPermissionDto() .setOrganizationUuid(project.getOrganizationUuid()) .setGroupId(null) .setRole(perm) .setResourceId(project.getId()); db.getDbClient().groupPermissionDao().insert(db.getSession(), dto); db.commit(); } }
@Test public void return_only_users_favorite() { OrganizationDto organizationDto = db.organizations().insert(); addComponent(ComponentTesting.newPrivateProjectDto(organizationDto).setDbKey("K1")); ComponentDto otherUserFavorite = ComponentTesting.newPrivateProjectDto(organizationDto).setDbKey("K42"); db.components().insertComponent(otherUserFavorite); db.favorites().add(otherUserFavorite, 42); db.commit(); SearchResponse result = call(); assertThat(result.getFavoritesList()).extracting(Favorite::getKey).containsExactly("K1"); }