@ServerSide
public class ComponentDao extends BaseDao<ComponentMapper, ComponentDto, String> implements DaoComponent {
- public ComponentDao() {
- this(System2.INSTANCE);
- }
-
public ComponentDao(System2 system) {
super(ComponentMapper.class, system);
}
private System2 system2;
- public AnalysisReportDao() {
- this(System2.INSTANCE);
- }
-
public AnalysisReportDao(System2 system2) {
this.system2 = system2;
}
private final UserSession userSession;
public DebtModelBackup(DbClient dbClient, DebtModelOperations debtModelOperations, RuleOperations ruleOperations,
- DebtModelPluginRepository debtModelPluginRepository, DebtCharacteristicsXMLImporter characteristicsXMLImporter, DebtRulesXMLImporter rulesXMLImporter,
- DebtModelXMLExporter debtModelXMLExporter, RuleDefinitionsLoader defLoader, UserSession userSession) {
- this(dbClient, debtModelOperations, ruleOperations, debtModelPluginRepository, characteristicsXMLImporter, rulesXMLImporter, debtModelXMLExporter,
- defLoader, System2.INSTANCE, userSession);
- }
-
- @VisibleForTesting
- DebtModelBackup(DbClient dbClient, DebtModelOperations debtModelOperations, RuleOperations ruleOperations,
DebtModelPluginRepository debtModelPluginRepository, DebtCharacteristicsXMLImporter characteristicsXMLImporter, DebtRulesXMLImporter rulesXMLImporter,
DebtModelXMLExporter debtModelXMLExporter, RuleDefinitionsLoader defLoader, System2 system2, UserSession userSession) {
this.dbClient = dbClient;
private final System2 system2;
private final UserSession userSession;
- public DebtModelOperations(DbClient dbClient, UserSession userSession) {
- this(dbClient, System2.INSTANCE, userSession);
- }
-
- @VisibleForTesting
- DebtModelOperations(DbClient dbClient, System2 system2, UserSession userSession) {
+ public DebtModelOperations(DbClient dbClient, System2 system2, UserSession userSession) {
this.dbClient = dbClient;
this.system2 = system2;
this.userSession = userSession;
private final DbClient dbClient;
private final IssueService issueService;
private final IssueUpdater updater;
- private final IssueChangeDao changeDao;
- public IssueCommentService(DbClient dbClient, IssueService issueService, IssueUpdater updater, IssueChangeDao changeDao) {
+ public IssueCommentService(DbClient dbClient, IssueService issueService, IssueUpdater updater) {
this.dbClient = dbClient;
this.issueService = issueService;
this.updater = updater;
- this.changeDao = changeDao;
}
public List<DefaultIssueComment> findComments(String issueKey) {
}
public List<DefaultIssueComment> findComments(DbSession session, Collection<String> issueKeys) {
- return changeDao.selectCommentsByIssues(session, issueKeys);
+ return dbClient.issueChangeDao().selectCommentsByIssues(session, issueKeys);
}
public IssueComment findComment(String commentKey) {
- return changeDao.selectCommentByKey(commentKey);
+ return dbClient.issueChangeDao().selectCommentByKey(commentKey);
}
public IssueComment addComment(String issueKey, String text, UserSession userSession) {
}
public IssueComment deleteComment(String commentKey, UserSession userSession) {
- DefaultIssueComment comment = changeDao.selectCommentByKey(commentKey);
+ DefaultIssueComment comment = dbClient.issueChangeDao().selectCommentByKey(commentKey);
if (comment == null) {
throw new NotFoundException("Comment not found: " + commentKey);
}
// check authorization
issueService.getByKey(comment.issueKey());
- changeDao.delete(commentKey);
+ dbClient.issueChangeDao().delete(commentKey);
return comment;
}
public IssueComment editComment(String commentKey, String text, UserSession userSession) {
- DefaultIssueComment comment = changeDao.selectCommentByKey(commentKey);
+ DefaultIssueComment comment = dbClient.issueChangeDao().selectCommentByKey(commentKey);
if (StringUtils.isBlank(text)) {
throw new BadRequestException("Cannot add empty comments to an issue");
}
IssueChangeDto dto = IssueChangeDto.of(comment);
dto.setUpdatedAt(System2.INSTANCE.now());
dto.setChangeData(text);
- changeDao.update(dto);
+ dbClient.issueChangeDao().update(dto);
return comment;
}
package org.sonar.server.qualityprofile.db;
-import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import org.sonar.api.utils.System2;
import org.sonar.core.persistence.DbSession;
import org.sonar.server.search.IndexDefinition;
import javax.annotation.CheckForNull;
+
import java.util.List;
public class ActiveRuleDao extends BaseDao<ActiveRuleMapper, ActiveRuleDto, ActiveRuleKey> {
private final RuleDao ruleDao;
private final QualityProfileDao profileDao;
- public ActiveRuleDao(QualityProfileDao profileDao, RuleDao ruleDao) {
- this(profileDao, ruleDao, System2.INSTANCE);
- }
-
- @VisibleForTesting
public ActiveRuleDao(QualityProfileDao profileDao, RuleDao ruleDao, System2 system) {
super(IndexDefinition.ACTIVE_RULE, ActiveRuleMapper.class, system);
this.ruleDao = ruleDao;
*/
package org.sonar.server.rule.db;
-import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.utils.System2;
import org.sonar.server.search.IndexDefinition;
import javax.annotation.CheckForNull;
+
import java.util.List;
public class RuleDao extends BaseDao<RuleMapper, RuleDto, RuleKey> {
- public RuleDao() {
- this(System2.INSTANCE);
- }
-
- @VisibleForTesting
public RuleDao(System2 system) {
super(IndexDefinition.RULE, RuleMapper.class, system);
}
package org.sonar.server.user.db;
-import com.google.common.annotations.VisibleForTesting;
import org.sonar.api.utils.System2;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.user.GroupDto;
*/
public class GroupDao extends BaseDao<GroupMapper, GroupDto, String> {
- public GroupDao() {
- this(System2.INSTANCE);
- }
-
- @VisibleForTesting
public GroupDao(System2 system) {
super(GroupMapper.class, system);
}
package org.sonar.server.batch;
-import java.io.ByteArrayInputStream;
-import java.util.Arrays;
-import javax.annotation.Nullable;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.sonar.server.ws.WsTester;
import org.sonar.test.DbTests;
+import javax.annotation.Nullable;
+
+import java.io.ByteArrayInputStream;
+import java.util.Arrays;
+
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
es.truncateIndices();
this.session = db.myBatis().openSession(false);
- DbClient dbClient = new DbClient(db.database(), db.myBatis(), new IssueDao(db.myBatis()), new ComponentDao());
+ componentDao = new ComponentDao(mock(System2.class));
+ DbClient dbClient = new DbClient(db.database(), db.myBatis(), new IssueDao(db.myBatis()), componentDao);
issueIndex = new IssueIndex(es.client(), System2.INSTANCE, userSessionRule);
issueIndexer = new IssueIndexer(null, es.client());
issueAuthorizationIndexer = new IssueAuthorizationIndexer(null, es.client());
issuesAction = new IssuesAction(dbClient, issueIndex, userSessionRule);
- componentDao = new ComponentDao();
tester = new WsTester(new BatchWs(new BatchIndex(mock(Server.class)), issuesAction));
}
import org.sonar.test.JsonAssert;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
public class ProvisionedProjectsActionTest {
DbClient dbClient;
DbSession dbSession;
ComponentDao componentDao;
+ System2 system2 = mock(System2.class);
@After
public void tearDown() {
@Before
public void setUp() {
- dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(), new SnapshotDao(System2.INSTANCE));
+ dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(system2), new SnapshotDao(System2.INSTANCE));
dbSession = dbClient.openSession(false);
componentDao = dbClient.componentDao();
db.truncateTables();
import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.core.persistence.DbTester;
import org.sonar.core.user.AuthorizationDao;
public void setUp() {
dbTester.truncateTables();
DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(),
- new ComponentDao(), new AuthorizationDao(dbTester.myBatis()), new ComponentIndexDao()
+ new ComponentDao(mock(System2.class)), new AuthorizationDao(dbTester.myBatis()), new ComponentIndexDao()
);
tester = new WsTester(new ComponentsWs(mock(ComponentAppAction.class), new SearchAction(dbClient, userSessionRule)));
}
@Before
public void setUp() {
- DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(), new SnapshotDao(system));
+ DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(system), new SnapshotDao(system));
sut = new ComputationService(dbClient, steps, activityService, settingsFactory, tempFolder, system);
// db contains project with key "P1"
settings.setProperty(ProcessProperties.PATH_DATA, dataDir.getAbsolutePath());
when(system.now()).thenReturn(NOW);
- DbClient dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(), new AnalysisReportDao(system));
+ DbClient dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(system), new AnalysisReportDao(system));
sut = new ReportQueue(dbClient, settings);
try (DbSession session = dbClient.openSession(false)) {
import org.junit.ClassRule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
+import org.sonar.api.utils.System2;
import org.sonar.core.persistence.DbTester;
import org.sonar.server.db.DbClient;
import org.sonar.server.rule.db.RuleDao;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
public class RuleCacheLoaderTest {
@Test
public void load_by_key() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new RuleDao());
+ DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new RuleDao(mock(System2.class)));
RuleCacheLoader loader = new RuleCacheLoader(dbClient);
assertThat(loader.load(RuleKey.of("squid", "R001")).getName()).isEqualTo("Rule One");
@Test
public void load_by_keys_is_not_supported() {
- DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new RuleDao());
+ DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new RuleDao(mock(System2.class)));
RuleCacheLoader loader = new RuleCacheLoader(dbClient);
try {
loader.loadAll(Collections.<RuleKey>emptyList());
public void setup() throws Exception {
dbTester.truncateTables();
session = dbTester.myBatis().openSession(false);
- dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new IssueDao(dbTester.myBatis()), new RuleDao());
+ dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new IssueDao(dbTester.myBatis()), new RuleDao(system2));
issueCache = new IssueCache(temp.newFile(), System2.INSTANCE);
system2 = mock(System2.class);
import org.junit.*;
import org.sonar.api.config.Settings;
import org.sonar.api.resources.Qualifiers;
+import org.sonar.api.utils.System2;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.DbTester;
public void setUp() {
esTester.truncateIndices();
session = db.myBatis().openSession(false);
- dbClient = new DbClient(db.database(), db.myBatis(), new IssueDao(db.myBatis()), new ComponentDao());
+ dbClient = new DbClient(db.database(), db.myBatis(), new IssueDao(db.myBatis()), new ComponentDao(mock(System2.class)));
sut = new PurgeRemovedViewsStep(new ViewIndex(esTester.client()), dbClient);
}
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown;
+import static org.mockito.Mockito.mock;
public class ShowActionTest {
@Before
public void setUp() {
dbTester.truncateTables();
- dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(), new SnapshotDao(System2.INSTANCE), new FileDependencyDao());
+ dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(mock(System2.class)), new SnapshotDao(System2.INSTANCE), new FileDependencyDao());
session = dbClient.openSession(false);
tester = new WsTester(new DependenciesWs(new ShowAction(dbClient, userSessionRule)));
controller = tester.controller("api/dependencies");
@Before
public void setUp() {
when(dbClient.openSession(false)).thenReturn(session);
+ when(dbClient.issueChangeDao()).thenReturn(changeDao);
- issueCommentService = new IssueCommentService(dbClient, issueService, updater, changeDao);
+ issueCommentService = new IssueCommentService(dbClient, issueService, updater);
}
@Test
private DbSession session;
+ System2 system2 = mock(System2.class);
+
@Before
public void setUp() {
dbTester.truncateTables();
qualityProfileDao = new QualityProfileDao(dbTester.myBatis(), mock(System2.class));
- componentDao = new ComponentDao();
+ componentDao = new ComponentDao(mock(System2.class));
- dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), qualityProfileDao, new ActiveRuleDao(qualityProfileDao, new RuleDao()));
+ dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), qualityProfileDao, new ActiveRuleDao(qualityProfileDao, new RuleDao(system2), system2));
session = dbClient.openSession(false);
xoo1 = LanguageTesting.newLanguage("xoo1");
private RoleDao roleDao;
+ System2 system2 = mock(System2.class);
+
@Before
public void setUp() {
dbTester.truncateTables();
dbClient = new DbClient(dbTester.database(), dbTester.myBatis(),
- new QualityProfileDao(dbTester.myBatis(), mock(System2.class)),
- new ComponentDao(),
+ new QualityProfileDao(dbTester.myBatis(), system2),
+ new ComponentDao(system2),
new AuthorizationDao(dbTester.myBatis()));
roleDao = new RoleDao();
session = dbClient.openSession(false);
package org.sonar.server.source.ws;
import org.junit.Rule;
+import org.sonar.api.utils.System2;
import org.sonar.server.source.db.FileSourceDao;
import org.junit.After;
import org.sonar.test.DbTests;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
@RunWith(MockitoJUnitRunner.class)
@Category(DbTests.class)
db.truncateTables();
this.session = db.myBatis().openSession(false);
- DbClient dbClient = new DbClient(db.database(), db.myBatis(), new FileSourceDao(db.myBatis()), new ComponentDao());
+ DbClient dbClient = new DbClient(db.database(), db.myBatis(), new FileSourceDao(db.myBatis()), new ComponentDao(mock(System2.class)));
tester = new WsTester(new SourcesWs(new HashAction(dbClient, userSessionRule)));
}
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
+import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown;
import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
public class LinesActionTest {
htmlSourceDecorator = new HtmlSourceDecorator();
sourceLineIndex = new SourceLineIndex(esTester.client());
- componentDao = new ComponentDao();
+ componentDao = new ComponentDao(mock(System2.class));
DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), componentDao);
session = dbClient.openSession(false);
wsTester = new WsTester(new SourcesWs(new LinesAction(dbClient, sourceLineIndex, htmlSourceDecorator, userSessionRule)));
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.utils.DateUtils;
+import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
+import static org.mockito.Mockito.mock;
+
public class ScmActionTest {
private static final String FILE_KEY = "FILE_KEY";
public void setUp() {
dbTester.truncateTables();
esTester.truncateIndices();
- dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao());
+ dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(mock(System2.class)));
session = dbClient.openSession(false);
tester = new WsTester(new SourcesWs(new ScmAction(dbClient, new SourceLineIndex(esTester.client()), userSessionRule)));
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
+import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
+import static org.mockito.Mockito.mock;
+
public class TestsListActionTest {
DbClient dbClient;
DbSession dbSession;
@Before
public void setUp() {
- dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao());
+ dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(mock(System2.class)));
dbSession = dbClient.openSession(false);
db.truncateTables();
es.truncateIndices();
public void select_by_key() {
setupData("select_by_key");
- GroupDto group = new GroupDao().getByKey(session, "sonar-users");
+ GroupDto group = new GroupDao(system2).getByKey(session, "sonar-users");
assertThat(group).isNotNull();
assertThat(group.getId()).isEqualTo(1L);
assertThat(group.getName()).isEqualTo("sonar-users");
System2 system2 = new System2();
UserDao userDao = new UserDao(dbTester.myBatis(), system2);
UserGroupDao userGroupDao = new UserGroupDao();
- GroupDao groupDao = new GroupDao();
+ GroupDao groupDao = new GroupDao(system2);
dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), userDao, userGroupDao, groupDao);
session = dbClient.openSession(false);
groupDao.insert(session, new GroupDto().setName("sonar-users"));
System2 system2 = new System2();
UserDao userDao = new UserDao(dbTester.myBatis(), system2);
UserGroupDao userGroupDao = new UserGroupDao();
- GroupDao groupDao = new GroupDao();
+ GroupDao groupDao = new GroupDao(system2);
dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), userDao, userGroupDao, groupDao);
session = dbClient.openSession(false);
groupDao.insert(session, new GroupDto().setName("sonar-users"));
System2 system2 = new System2();
UserDao userDao = new UserDao(dbTester.myBatis(), system2);
UserGroupDao userGroupDao = new UserGroupDao();
- GroupDao groupDao = new GroupDao();
+ GroupDao groupDao = new GroupDao(system2);
dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), userDao, userGroupDao, groupDao);
session = dbClient.openSession(false);
groupDao.insert(session, new GroupDto().setName("sonar-users"));
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.sonar.api.config.Settings;
+import org.sonar.api.utils.System2;
import org.sonar.core.persistence.DbTester;
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.db.DbClient;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
@Category(DbTests.class)
public class ViewIndexerTest {
public void setUp() {
dbTester.truncateTables();
esTester.truncateIndices();
- indexer = new ViewIndexer(new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao()), esTester.client());
+ indexer = new ViewIndexer(new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(mock(System2.class))), esTester.client());
indexer.setEnabled(true);
}
private ClassLoader classloader;
private Map<String, String> propertyToBundles;
- public DefaultI18n(PluginRepository pluginRepository) {
- this(pluginRepository, System2.INSTANCE);
- }
-
- @VisibleForTesting
- DefaultI18n(PluginRepository pluginRepository, System2 system2) {
+ public DefaultI18n(PluginRepository pluginRepository, System2 system2) {
this.pluginRepository = pluginRepository;
this.system2 = system2;
// SONAR-2927
projects / sonarqube.git / commitdiff