@@ -23,13 +23,11 @@ import org.sonar.api.batch.fs.FilePredicates; | |||
import org.sonar.api.batch.fs.FileSystem; | |||
import org.sonar.api.batch.fs.InputFile; | |||
import org.sonar.api.batch.fs.InputFile.Type; | |||
import org.sonar.api.batch.rule.Severity; | |||
import org.sonar.api.batch.sensor.Sensor; | |||
import org.sonar.api.batch.sensor.SensorContext; | |||
import org.sonar.api.batch.sensor.SensorDescriptor; | |||
import org.sonar.api.batch.sensor.issue.NewIssue; | |||
import org.sonar.api.rule.RuleKey; | |||
import org.sonar.api.utils.Version; | |||
import org.sonar.xoo.Xoo; | |||
import org.sonar.xoo.Xoo2; | |||
@@ -22,17 +22,11 @@ package org.sonar.xoo.rule; | |||
import org.junit.Rule; | |||
import org.junit.Test; | |||
import org.junit.rules.TemporaryFolder; | |||
import org.sonar.api.SonarEdition; | |||
import org.sonar.api.SonarQubeSide; | |||
import org.sonar.api.batch.fs.internal.DefaultInputFile; | |||
import org.sonar.api.batch.fs.internal.TestInputFileBuilder; | |||
import org.sonar.api.batch.rule.Severity; | |||
import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor; | |||
import org.sonar.api.batch.sensor.internal.SensorContextTester; | |||
import org.sonar.api.batch.sensor.issue.Issue; | |||
import org.sonar.api.config.internal.MapSettings; | |||
import org.sonar.api.internal.SonarRuntimeImpl; | |||
import org.sonar.api.utils.Version; | |||
import org.sonar.xoo.Xoo; | |||
import java.io.IOException; |
@@ -145,7 +145,7 @@ public class BitbucketCloudRestClientTest { | |||
RepositoryList repositoryList = underTest.searchRepos("user:apppwd", "", null, 1, 100); | |||
assertThat(repositoryList.getNext()).isNull(); | |||
assertThat(repositoryList.getPage()).isEqualTo(1); | |||
assertThat(repositoryList.getPage()).isOne(); | |||
assertThat(repositoryList.getPagelen()).isEqualTo(100); | |||
assertThat(repositoryList.getValues()) | |||
.hasSize(1) |
@@ -514,9 +514,7 @@ public class BitbucketServerRestClientTest { | |||
.setBody("this is not a json payload")); | |||
String serverUrl = server.url("/").toString(); | |||
assertThatThrownBy(() -> { | |||
underTest.validateUrl(serverUrl); | |||
}) | |||
assertThatThrownBy(() -> underTest.validateUrl(serverUrl)) | |||
.isInstanceOf(IllegalArgumentException.class) | |||
.hasMessage("Unable to contact Bitbucket server, got an unexpected response"); | |||
} |
@@ -223,7 +223,7 @@ public class GitlabHttpClientTest { | |||
ProjectList projectList = underTest.searchProjects(gitlabUrl, "pat", "example", 1, 10); | |||
assertThat(projectList.getPageNumber()).isEqualTo(1); | |||
assertThat(projectList.getPageNumber()).isOne(); | |||
assertThat(projectList.getPageSize()).isEqualTo(10); | |||
assertThat(projectList.getTotal()).isEqualTo(3); | |||
@@ -263,7 +263,7 @@ public class GitlabHttpClientTest { | |||
ProjectList projectList = underTest.searchProjects(gitlabUrl, "pat", "example", 1, 10); | |||
assertThat(projectList.getPageNumber()).isEqualTo(1); | |||
assertThat(projectList.getPageNumber()).isOne(); | |||
assertThat(projectList.getPageSize()).isEqualTo(10); | |||
assertThat(projectList.getTotal()).isNull(); | |||
@@ -300,8 +300,8 @@ public class GitlabHttpClientTest { | |||
ProjectList projectList = underTest.searchProjects(gitlabUrl, "pat", "example", 1, 10); | |||
assertThat(projectList.getPageNumber()).isEqualTo(1); | |||
assertThat(projectList.getPageSize()).isEqualTo(1); | |||
assertThat(projectList.getPageNumber()).isOne(); | |||
assertThat(projectList.getPageSize()).isOne(); | |||
assertThat(projectList.getTotal()).isEqualTo(2); | |||
assertThat(projectList.getProjects()).hasSize(1); |
@@ -29,8 +29,6 @@ import org.sonar.api.config.Configuration; | |||
import org.sonar.api.config.PropertyDefinition; | |||
import org.sonar.api.server.ServerSide; | |||
import static java.lang.String.format; | |||
@ServerSide | |||
public class BitbucketSettings { | |||
@@ -23,8 +23,6 @@ import javax.annotation.Nullable; | |||
import org.sonar.api.server.ServerSide; | |||
import org.sonar.api.server.authentication.UserIdentity; | |||
import static java.lang.String.format; | |||
@ServerSide | |||
public class UserIdentityFactory { | |||
@@ -46,7 +46,7 @@ public class GsonGroupTest { | |||
"}]"); | |||
assertThat(groups).isNotNull(); | |||
assertThat(groups.size()).isEqualTo(1); | |||
assertThat(groups.size()).isOne(); | |||
assertThat(groups.get(0).getFullPath()).isEqualTo("my-awesome-group/my-project"); | |||
} | |||
} |
@@ -59,9 +59,10 @@ public class LdapSearchTest { | |||
assertThat(search.toString()).isEqualTo("LdapSearch{baseDn=dc=example,dc=org, scope=subtree, request=(objectClass={0}), parameters=[inetOrgPerson], attributes=[objectClass]}"); | |||
assertThat(enumerationToArrayList(search.find()).size()).isEqualTo(3); | |||
assertThatThrownBy(() -> search.findUnique()) | |||
assertThatThrownBy(search::findUnique) | |||
.isInstanceOf(NamingException.class) | |||
.hasMessage("Non unique result for " + search.toString()); | |||
} | |||
@Test | |||
@@ -78,7 +79,7 @@ public class LdapSearchTest { | |||
assertThat(search.getRequest()).isEqualTo("(objectClass={0})"); | |||
assertThat(search.getParameters()).isEqualTo(new String[] {"inetOrgPerson"}); | |||
assertThat(search.getReturningAttributes()).isEqualTo(new String[] {"cn"}); | |||
assertThat(search.toString()).isEqualTo("LdapSearch{baseDn=dc=example,dc=org, scope=onelevel, request=(objectClass={0}), parameters=[inetOrgPerson], attributes=[cn]}"); | |||
assertThat(search).hasToString("LdapSearch{baseDn=dc=example,dc=org, scope=onelevel, request=(objectClass={0}), parameters=[inetOrgPerson], attributes=[cn]}"); | |||
assertThat(enumerationToArrayList(search.find()).size()).isZero(); | |||
assertThat(search.findUnique()).isNull(); | |||
} | |||
@@ -97,9 +98,9 @@ public class LdapSearchTest { | |||
assertThat(search.getRequest()).isEqualTo("(objectClass={0})"); | |||
assertThat(search.getParameters()).isEqualTo(new String[] {"uidObject"}); | |||
assertThat(search.getReturningAttributes()).isEqualTo(new String[] {"uid"}); | |||
assertThat(search.toString()).isEqualTo( | |||
assertThat(search).hasToString( | |||
"LdapSearch{baseDn=cn=bind,ou=users,dc=example,dc=org, scope=object, request=(objectClass={0}), parameters=[uidObject], attributes=[uid]}"); | |||
assertThat(enumerationToArrayList(search.find()).size()).isEqualTo(1); | |||
assertThat(enumerationToArrayList(search.find())).hasSize(1); | |||
assertThat(search.findUnique()).isNotNull(); | |||
} | |||
@@ -57,7 +57,7 @@ public class LdapSettingsManagerTest { | |||
public void testContextFactoriesWithSingleLdap() { | |||
LdapSettingsManager settingsManager = new LdapSettingsManager( | |||
generateSingleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery()); | |||
assertThat(settingsManager.getContextFactories().size()).isEqualTo(1); | |||
assertThat(settingsManager.getContextFactories()).hasSize(1); | |||
} | |||
/** | |||
@@ -68,9 +68,9 @@ public class LdapSettingsManagerTest { | |||
public void testContextFactoriesWithMultipleLdap() { | |||
LdapSettingsManager settingsManager = new LdapSettingsManager( | |||
generateMultipleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery()); | |||
assertThat(settingsManager.getContextFactories().size()).isEqualTo(2); | |||
assertThat(settingsManager.getContextFactories()).hasSize(2); | |||
// We do it twice to make sure the settings keep the same. | |||
assertThat(settingsManager.getContextFactories().size()).isEqualTo(2); | |||
assertThat(settingsManager.getContextFactories()).hasSize(2); | |||
} | |||
@Test | |||
@@ -81,7 +81,7 @@ public class LdapSettingsManagerTest { | |||
when(ldapAutodiscovery.getLdapServers("example.org")).thenReturn(Arrays.asList(ldap1, ldap2)); | |||
LdapSettingsManager settingsManager = new LdapSettingsManager( | |||
generateAutodiscoverSettings().asConfig(), ldapAutodiscovery); | |||
assertThat(settingsManager.getContextFactories().size()).isEqualTo(2); | |||
assertThat(settingsManager.getContextFactories()).hasSize(2); | |||
} | |||
@Test | |||
@@ -104,9 +104,9 @@ public class LdapSettingsManagerTest { | |||
public void testUserMappings() { | |||
LdapSettingsManager settingsManager = new LdapSettingsManager( | |||
generateMultipleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery()); | |||
assertThat(settingsManager.getUserMappings().size()).isEqualTo(2); | |||
assertThat(settingsManager.getUserMappings()).hasSize(2); | |||
// We do it twice to make sure the settings keep the same. | |||
assertThat(settingsManager.getUserMappings().size()).isEqualTo(2); | |||
assertThat(settingsManager.getUserMappings()).hasSize(2); | |||
} | |||
/** | |||
@@ -117,9 +117,9 @@ public class LdapSettingsManagerTest { | |||
public void testGroupMappings() { | |||
LdapSettingsManager settingsManager = new LdapSettingsManager( | |||
generateMultipleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery()); | |||
assertThat(settingsManager.getGroupMappings().size()).isEqualTo(2); | |||
assertThat(settingsManager.getGroupMappings()).hasSize(2); | |||
// We do it twice to make sure the settings keep the same. | |||
assertThat(settingsManager.getGroupMappings().size()).isEqualTo(2); | |||
assertThat(settingsManager.getGroupMappings()).hasSize(2); | |||
} | |||
/** |
@@ -34,7 +34,7 @@ public class LdapUserMappingTest { | |||
assertThat(userMapping.getRealNameAttribute()).isEqualTo("cn"); | |||
assertThat(userMapping.getEmailAttribute()).isEqualTo("mail"); | |||
assertThat(userMapping.toString()).isEqualTo("LdapUserMapping{" + | |||
assertThat(userMapping).hasToString("LdapUserMapping{" + | |||
"baseDn=null," + | |||
" request=(&(objectClass=inetOrgPerson)(uid={0}))," + | |||
" realNameAttribute=cn," + | |||
@@ -54,7 +54,7 @@ public class LdapUserMappingTest { | |||
assertThat(search.getParameters()).isEqualTo(new String[] {"tester"}); | |||
assertThat(search.getReturningAttributes()).isNull(); | |||
assertThat(userMapping.toString()).isEqualTo("LdapUserMapping{" + | |||
assertThat(userMapping).hasToString("LdapUserMapping{" + | |||
"baseDn=cn=users," + | |||
" request=(&(objectClass=user)(sAMAccountName={0}))," + | |||
" realNameAttribute=cn," + |
@@ -60,7 +60,7 @@ public class LdapUsersProviderTest { | |||
details = usersProvider.getUserDetails("without_email"); | |||
assertThat(details.getName()).isEqualTo("Without Email"); | |||
assertThat(details.getEmail()).isEqualTo(""); | |||
assertThat(details.getEmail()).isEmpty(); | |||
details = usersProvider.getUserDetails("notfound"); | |||
assertThat(details).isNull(); |
@@ -104,7 +104,7 @@ public class SamlSettingsTest { | |||
public void return_user_email_attribute() { | |||
settings.setProperty("sonar.auth.saml.user.email", "userEmail"); | |||
assertThat(underTest.getUserEmail().get()).isEqualTo("userEmail"); | |||
assertThat(underTest.getUserEmail()).contains("userEmail"); | |||
} | |||
@Test | |||
@@ -116,7 +116,7 @@ public class SamlSettingsTest { | |||
public void return_group_name_attribute() { | |||
settings.setProperty("sonar.auth.saml.group.name", "groupName"); | |||
assertThat(underTest.getGroupName().get()).isEqualTo("groupName"); | |||
assertThat(underTest.getGroupName()).contains("groupName"); | |||
} | |||
@Test |
@@ -19,12 +19,13 @@ | |||
*/ | |||
package org.sonar.ce.task.projectanalysis.measure; | |||
import com.google.common.base.Predicates; | |||
import java.util.Objects; | |||
import java.util.stream.Collectors; | |||
import java.util.stream.StreamSupport; | |||
import javax.annotation.CheckForNull; | |||
import org.sonar.ce.task.projectanalysis.api.measurecomputer.MeasureComputerWrapper; | |||
import static com.google.common.base.Preconditions.checkState; | |||
import static com.google.common.collect.FluentIterable.from; | |||
import static java.util.Objects.requireNonNull; | |||
public class MeasureComputersHolderImpl implements MutableMeasureComputersHolder { | |||
@@ -42,6 +43,6 @@ public class MeasureComputersHolderImpl implements MutableMeasureComputersHolder | |||
public void setMeasureComputers(Iterable<MeasureComputerWrapper> measureComputers) { | |||
requireNonNull(measureComputers, "Measure computers cannot be null"); | |||
checkState(this.measureComputers == null, "Measure computers have already been initialized"); | |||
this.measureComputers = from(measureComputers).filter(Predicates.notNull()).toList(); | |||
this.measureComputers = StreamSupport.stream(measureComputers.spliterator(), false).filter(Objects::nonNull).collect(Collectors.toList()); | |||
} | |||
} |
@@ -19,7 +19,6 @@ | |||
*/ | |||
package org.sonar.ce.task.projectanalysis.qualitygate; | |||
import com.google.common.collect.ImmutableMap; | |||
import java.util.Locale; | |||
import java.util.Map; | |||
import javax.annotation.CheckForNull; | |||
@@ -32,7 +31,7 @@ import org.sonar.core.i18n.I18n; | |||
import static java.util.Objects.requireNonNull; | |||
public final class EvaluationResultTextConverterImpl implements EvaluationResultTextConverter { | |||
private static final Map<Condition.Operator, String> OPERATOR_LABELS = ImmutableMap.of( | |||
private static final Map<Condition.Operator, String> OPERATOR_LABELS = Map.of( | |||
Condition.Operator.GREATER_THAN, ">", | |||
Condition.Operator.LESS_THAN, "<"); | |||
@@ -40,7 +40,7 @@ import static org.sonar.ce.task.projectanalysis.source.linereader.RangeOffsetCon | |||
public class SymbolsLineReader implements LineReader { | |||
private static final Logger LOG = Loggers.get(HighlightingLineReader.class); | |||
private static final Logger LOG = Loggers.get(SymbolsLineReader.class); | |||
private final Component file; | |||
private final RangeOffsetConverter rangeOffsetConverter; |
@@ -19,7 +19,6 @@ | |||
*/ | |||
package org.sonar.ce.task.projectanalysis.step; | |||
import com.google.common.collect.ImmutableSet; | |||
import java.util.ArrayList; | |||
import java.util.List; | |||
import java.util.Set; | |||
@@ -43,7 +42,7 @@ import static org.sonar.core.config.CorePropertyDefinitions.SONAR_ANALYSIS_DETEC | |||
public class PersistAnalysisPropertiesStep implements ComputationStep { | |||
private static final String SONAR_PULL_REQUEST = "sonar.pullrequest."; | |||
private static final Set<String> ANALYSIS_PROPERTIES_TO_PERSIST = ImmutableSet.of(SONAR_ANALYSIS_DETECTEDSCM, SONAR_ANALYSIS_DETECTEDCI); | |||
private static final Set<String> ANALYSIS_PROPERTIES_TO_PERSIST = Set.of(SONAR_ANALYSIS_DETECTEDSCM, SONAR_ANALYSIS_DETECTEDCI); | |||
private final DbClient dbClient; | |||
private final AnalysisMetadataHolder analysisMetadataHolder; |
@@ -53,9 +53,7 @@ public class PersistLiveMeasuresStep implements ComputationStep { | |||
/** | |||
* List of metrics that should not be persisted on file measure. | |||
*/ | |||
private static final Set<String> NOT_TO_PERSIST_ON_FILE_METRIC_KEYS = unmodifiableSet(new HashSet<>(asList( | |||
FILE_COMPLEXITY_DISTRIBUTION_KEY, | |||
FUNCTION_COMPLEXITY_DISTRIBUTION_KEY))); | |||
private static final Set<String> NOT_TO_PERSIST_ON_FILE_METRIC_KEYS = Set.of(FILE_COMPLEXITY_DISTRIBUTION_KEY, FUNCTION_COMPLEXITY_DISTRIBUTION_KEY); | |||
private final DbClient dbClient; | |||
private final MetricRepository metricRepository; |
@@ -19,7 +19,6 @@ | |||
*/ | |||
package org.sonar.ce.task.projectanalysis.step; | |||
import com.google.common.collect.ImmutableMap; | |||
import java.util.HashSet; | |||
import java.util.List; | |||
import java.util.Map; | |||
@@ -40,7 +39,7 @@ import org.sonar.scanner.protocol.output.ScannerReport.ComponentLink.ComponentLi | |||
import static com.google.common.base.Preconditions.checkArgument; | |||
public class PersistProjectLinksStep implements ComputationStep { | |||
private static final Map<ComponentLinkType, String> typesConverter = ImmutableMap.of( | |||
private static final Map<ComponentLinkType, String> typesConverter = Map.of( | |||
ComponentLinkType.HOME, ProjectLinkDto.TYPE_HOME_PAGE, | |||
ComponentLinkType.SCM, ProjectLinkDto.TYPE_SOURCES, | |||
ComponentLinkType.CI, ProjectLinkDto.TYPE_CI, |
@@ -26,7 +26,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; | |||
public class AnalysisImplTest { | |||
private static final long ID = 10; | |||
private static final String UUID = "uuid "; | |||
private static final long CREATED_AT = 123456789L; | |||
@@ -62,7 +61,7 @@ public class AnalysisImplTest { | |||
.setUuid(UUID) | |||
.setCreatedAt(CREATED_AT) | |||
.build().toString()) | |||
.isEqualTo("Analysis{uuid='uuid ', createdAt=123456789}"); | |||
.isEqualTo("Analysis{uuid='uuid ', createdAt=123456789}"); | |||
} | |||
@Test | |||
@@ -80,13 +79,13 @@ public class AnalysisImplTest { | |||
.setCreatedAt(CREATED_AT) | |||
.build(); | |||
assertThat(analysis).isEqualTo(analysis); | |||
assertThat(analysis).isEqualTo(sameAnalysis); | |||
assertThat(analysis).isNotEqualTo(otherAnalysis); | |||
assertThat(analysis).isNotEqualTo(null); | |||
assertThat(analysis.hashCode()).isEqualTo(analysis.hashCode()); | |||
assertThat(analysis.hashCode()).isEqualTo(sameAnalysis.hashCode()); | |||
assertThat(analysis) | |||
.isEqualTo(analysis) | |||
.isEqualTo(sameAnalysis) | |||
.isNotEqualTo(otherAnalysis) | |||
.isNotNull() | |||
.hasSameHashCodeAs(analysis.hashCode()) | |||
.hasSameHashCodeAs(sameAnalysis.hashCode()); | |||
assertThat(analysis.hashCode()).isNotEqualTo(otherAnalysis.hashCode()); | |||
} | |||
} |
@@ -177,7 +177,7 @@ public class AnalysisMetadataHolderImplTest { | |||
underTest.setCrossProjectDuplicationEnabled(true); | |||
assertThat(underTest.isCrossProjectDuplicationEnabled()).isEqualTo(true); | |||
assertThat(underTest.isCrossProjectDuplicationEnabled()).isTrue(); | |||
} | |||
@Test | |||
@@ -186,7 +186,7 @@ public class AnalysisMetadataHolderImplTest { | |||
underTest.setCrossProjectDuplicationEnabled(false); | |||
assertThat(underTest.isCrossProjectDuplicationEnabled()).isEqualTo(false); | |||
assertThat(underTest.isCrossProjectDuplicationEnabled()).isFalse(); | |||
} | |||
@Test |
@@ -38,24 +38,25 @@ public class ScannerPluginTest { | |||
public void verify_toString() { | |||
ScannerPlugin plugin = new ScannerPlugin("key", "base", 12345L); | |||
assertThat(plugin.toString()).isEqualTo("ScannerPlugin{key='key', basePluginKey='base', updatedAt='12345'}"); | |||
assertThat(plugin).hasToString("ScannerPlugin{key='key', basePluginKey='base', updatedAt='12345'}"); | |||
} | |||
@Test | |||
public void equals_is_based_on_key_only() { | |||
ScannerPlugin plugin = new ScannerPlugin("key", "base", 12345L); | |||
assertThat(plugin).isEqualTo(plugin); | |||
assertThat(plugin).isEqualTo(new ScannerPlugin("key", null, 45678L)); | |||
assertThat(plugin).isNotEqualTo(new ScannerPlugin("key2", "base", 12345L)); | |||
assertThat(plugin).isNotEqualTo(null); | |||
assertThat(plugin).isNotEqualTo("toto"); | |||
assertThat(plugin) | |||
.isEqualTo(plugin) | |||
.isEqualTo(new ScannerPlugin("key", null, 45678L)) | |||
.isNotEqualTo(new ScannerPlugin("key2", "base", 12345L)) | |||
.isNotNull() | |||
.isNotEqualTo("toto"); | |||
} | |||
@Test | |||
public void hashcode_is_based_on_key_only() { | |||
ScannerPlugin plugin = new ScannerPlugin("key", "base", 12345L); | |||
assertThat(plugin.hashCode()).isEqualTo("key".hashCode()); | |||
assertThat(plugin).hasSameHashCodeAs("key"); | |||
} | |||
} |
@@ -97,19 +97,19 @@ public class ComponentImplTest { | |||
ComponentImpl sameComponent = new ComponentImpl("Project1", Component.Type.PROJECT, null); | |||
ComponentImpl anotherComponent = new ComponentImpl("Project2", Component.Type.PROJECT, null); | |||
assertThat(component).isEqualTo(component); | |||
assertThat(component).isEqualTo(sameComponent); | |||
assertThat(component).isNotEqualTo(anotherComponent); | |||
assertThat(component).isNotEqualTo(null); | |||
assertThat(component.hashCode()).isEqualTo(component.hashCode()); | |||
assertThat(component.hashCode()).isEqualTo(sameComponent.hashCode()); | |||
assertThat(component) | |||
.isEqualTo(component) | |||
.isEqualTo(sameComponent) | |||
.isNotEqualTo(anotherComponent) | |||
.isNotNull() | |||
.hasSameHashCodeAs(component) | |||
.hasSameHashCodeAs(sameComponent); | |||
assertThat(component.hashCode()).isNotEqualTo(anotherComponent.hashCode()); | |||
} | |||
@Test | |||
public void test_to_string() { | |||
assertThat(new ComponentImpl("File", Component.Type.FILE, new ComponentImpl.FileAttributesImpl("xoo", true)).toString()) | |||
.isEqualTo("ComponentImpl{key=File, type='FILE', fileAttributes=FileAttributesImpl{languageKey='xoo', unitTest=true}}"); | |||
assertThat(new ComponentImpl("File", Component.Type.FILE, new ComponentImpl.FileAttributesImpl("xoo", true))) | |||
.hasToString("ComponentImpl{key=File, type='FILE', fileAttributes=FileAttributesImpl{languageKey='xoo', unitTest=true}}"); | |||
} | |||
} |
@@ -257,7 +257,7 @@ public class MeasureComputerContextImplTest { | |||
.setSeverity("MAJOR") | |||
.setStatus("CLOSED") | |||
.setResolution("FIXED") | |||
.setEffort(Duration.create(10l)); | |||
.setEffort(Duration.create(10L)); | |||
MeasureComputerContextImpl underTest = newContext(PROJECT_REF, Arrays.asList(issue)); | |||
@@ -268,7 +268,7 @@ public class MeasureComputerContextImplTest { | |||
assertThat(result.severity()).isEqualTo("MAJOR"); | |||
assertThat(result.status()).isEqualTo("CLOSED"); | |||
assertThat(result.resolution()).isEqualTo("FIXED"); | |||
assertThat(result.effort()).isEqualTo(Duration.create(10l)); | |||
assertThat(result.effort()).isEqualTo(Duration.create(10L)); | |||
} | |||
private MeasureComputerContextImpl newContext(int componentRef) { |
@@ -159,7 +159,7 @@ public class MeasureComputerDefinitionImplTest { | |||
assertThat(computer).isEqualTo(computer) | |||
.isEqualTo(sameComputer) | |||
.isNotEqualTo(anotherComputer) | |||
.isNotEqualTo(null); | |||
.isNotNull(); | |||
assertThat(computer) | |||
.hasSameHashCodeAs(computer) |
@@ -31,7 +31,7 @@ public class MeasureImplTest { | |||
@Test | |||
public void get_int_value() { | |||
MeasureImpl measure = new MeasureImpl(Measure.newMeasureBuilder().create(1)); | |||
assertThat(measure.getIntValue()).isEqualTo(1); | |||
assertThat(measure.getIntValue()).isOne(); | |||
} | |||
@Test | |||
@@ -63,7 +63,7 @@ public class MeasureImplTest { | |||
@Test | |||
public void get_long_value() { | |||
MeasureImpl measure = new MeasureImpl(Measure.newMeasureBuilder().create(1L)); | |||
assertThat(measure.getLongValue()).isEqualTo(1L); | |||
assertThat(measure.getLongValue()).isOne(); | |||
} | |||
@Test |
@@ -52,6 +52,6 @@ public class CeTaskImplTest { | |||
@Test | |||
public void verify_toString() { | |||
assertThat(new CeTaskImpl(SOME_ID, CeTask.Status.SUCCESS).toString()).isEqualTo("CeTaskImpl{id='some id', status=SUCCESS}"); | |||
assertThat(new CeTaskImpl(SOME_ID, CeTask.Status.SUCCESS)).hasToString("CeTaskImpl{id='some id', status=SUCCESS}"); | |||
} | |||
} |
@@ -124,8 +124,8 @@ public class ConditionImplTest { | |||
@Test | |||
public void toString_ConditionImpl_of_type_different_from_NO_VALUE() { | |||
assertThat(builder.build().toString()) | |||
.isEqualTo( | |||
assertThat(builder.build()) | |||
.hasToString( | |||
"ConditionImpl{status=OK, metricKey='metricKey', operator=GREATER_THAN, errorThreshold='error threshold', value='value'}"); | |||
} | |||
@@ -134,8 +134,8 @@ public class ConditionImplTest { | |||
builder.setStatus(QualityGate.EvaluationStatus.NO_VALUE) | |||
.setValue(null); | |||
assertThat(builder.build().toString()) | |||
.isEqualTo( | |||
assertThat(builder.build()) | |||
.hasToString( | |||
"ConditionImpl{status=NO_VALUE, metricKey='metricKey', operator=GREATER_THAN, errorThreshold='error threshold', value='null'}"); | |||
} | |||
@@ -62,8 +62,8 @@ public class ProjectImplTest { | |||
@Test | |||
public void verify_toString() { | |||
assertThat(new ProjectImpl(SOME_UUID, SOME_KEY, SOME_NAME).toString()) | |||
.isEqualTo("ProjectImpl{uuid='some uuid', key='some key', name='some name'}"); | |||
assertThat(new ProjectImpl(SOME_UUID, SOME_KEY, SOME_NAME)) | |||
.hasToString("ProjectImpl{uuid='some uuid', key='some key', name='some name'}"); | |||
} | |||
} |
@@ -83,7 +83,7 @@ public class QualityGateImplTest { | |||
public void verify_toString() { | |||
when(condition.toString()).thenReturn("{Condition}"); | |||
assertThat(underTest.toString()) | |||
.isEqualTo("QualityGateImpl{id='some id', name='some name', status=OK, conditions=[{Condition}]}"); | |||
assertThat(underTest) | |||
.hasToString("QualityGateImpl{id='some id', name='some name', status=OK, conditions=[{Condition}]}"); | |||
} | |||
} |
@@ -19,14 +19,13 @@ | |||
*/ | |||
package org.sonar.ce.task.projectanalysis.component; | |||
import com.google.common.base.Function; | |||
import java.util.ArrayList; | |||
import java.util.List; | |||
import java.util.NoSuchElementException; | |||
import javax.annotation.Nonnull; | |||
import java.util.stream.Collectors; | |||
import java.util.stream.StreamSupport; | |||
import static com.google.common.base.Preconditions.checkArgument; | |||
import static com.google.common.collect.FluentIterable.from; | |||
class CallRecorderPathAwareVisitor extends PathAwareVisitorAdapter<Integer> { | |||
final List<PathAwareCallRecord> callsRecords = new ArrayList<>(); | |||
@@ -86,13 +85,7 @@ class CallRecorderPathAwareVisitor extends PathAwareVisitorAdapter<Integer> { | |||
} | |||
private static List<Integer> toValueList(Path<Integer> path) { | |||
return from(path.getCurrentPath()).transform(new Function<PathElement<Integer>, Integer>() { | |||
@Nonnull | |||
@Override | |||
public Integer apply(@Nonnull PathElement<Integer> input) { | |||
return input.getElement(); | |||
} | |||
}).toList(); | |||
return StreamSupport.stream(path.getCurrentPath().spliterator(), false).map(PathElement::getElement).collect(Collectors.toList()); | |||
} | |||
private static Integer getParent(Path<Integer> path) { |
@@ -226,9 +226,9 @@ public class ComponentImplTest { | |||
public void hashCode_is_hashcode_of_uuid() { | |||
ComponentImpl.Builder builder = buildSimpleComponent(FILE, "1").setUuid(UUID); | |||
assertThat(builder.build().hashCode()).isEqualTo(builder.build().hashCode()); | |||
assertThat(builder.build().hashCode()).isEqualTo(buildSimpleComponent(FILE, "2").setUuid(UUID).build().hashCode()); | |||
assertThat(builder.build().hashCode()).isEqualTo(UUID.hashCode()); | |||
assertThat(builder.build()).hasSameHashCodeAs(builder.build().hashCode()); | |||
assertThat(builder.build()).hasSameHashCodeAs(buildSimpleComponent(FILE, "2").setUuid(UUID).build().hashCode()); | |||
assertThat(builder.build()).hasSameHashCodeAs(UUID.hashCode()); | |||
} | |||
private static ComponentImpl.Builder buildSimpleComponent(Component.Type type, String dbKey) { |
@@ -654,7 +654,7 @@ public class ComponentTreeBuilderTest { | |||
Component root = call(project); | |||
Component dir = root.getChildren().iterator().next(); | |||
Component file = dir.getChildren().iterator().next(); | |||
assertThat(file.getFileAttributes().getLines()).isEqualTo(1); | |||
assertThat(file.getFileAttributes().getLines()).isOne(); | |||
assertThat(file.getFileAttributes().getLanguageKey()).isNull(); | |||
assertThat(file.getFileAttributes().isUnitTest()).isFalse(); | |||
} | |||
@@ -698,7 +698,7 @@ public class ComponentTreeBuilderTest { | |||
Component root = call(project); | |||
Component dir = root.getChildren().iterator().next(); | |||
Component file = dir.getChildren().iterator().next(); | |||
assertThat(file.getFileAttributes().getLines()).isEqualTo(1); | |||
assertThat(file.getFileAttributes().getLines()).isOne(); | |||
assertThat(file.getFileAttributes().getLanguageKey()).isEqualTo("js"); | |||
assertThat(file.getFileAttributes().isUnitTest()).isTrue(); | |||
} |
@@ -70,7 +70,7 @@ public class FileAttributesTest { | |||
@Test | |||
public void test_toString() { | |||
assertThat(new FileAttributes(true, "java", 10).toString()).isEqualTo("FileAttributes{languageKey='java', unitTest=true, lines=10}"); | |||
assertThat(new FileAttributes(false, null, 1).toString()).isEqualTo("FileAttributes{languageKey='null', unitTest=false, lines=1}"); | |||
assertThat(new FileAttributes(true, "java", 10)).hasToString("FileAttributes{languageKey='java', unitTest=true, lines=10}"); | |||
assertThat(new FileAttributes(false, null, 1)).hasToString("FileAttributes{languageKey='null', unitTest=false, lines=1}"); | |||
} | |||
} |
@@ -20,7 +20,6 @@ | |||
package org.sonar.ce.task.projectanalysis.container; | |||
import com.google.common.base.Function; | |||
import com.google.common.base.Predicate; | |||
import com.google.common.collect.ImmutableList; | |||
import java.lang.reflect.Modifier; | |||
import java.util.ArrayList; | |||
@@ -41,7 +40,6 @@ import org.sonar.ce.task.step.ComputationStep; | |||
import org.sonar.core.platform.ComponentContainer; | |||
import org.sonar.core.util.stream.MoreCollectors; | |||
import static com.google.common.collect.FluentIterable.from; | |||
import static com.google.common.collect.Sets.difference; | |||
import static org.assertj.core.api.Assertions.assertThat; | |||
import static org.mockito.Mockito.mock; | |||
@@ -175,19 +173,10 @@ public class ProjectAnalysisTaskContainerPopulatorTest { | |||
@Override | |||
public <T> List<T> getComponentsByType(final Class<T> type) { | |||
return from(added) | |||
.filter(new Predicate<Object>() { | |||
@Override | |||
public boolean apply(@Nonnull Object input) { | |||
return input.getClass().getSimpleName().contains(type.getSimpleName()); | |||
} | |||
}).transform(new Function<Object, T>() { | |||
@Override | |||
@Nonnull | |||
public T apply(@Nonnull Object input) { | |||
return (T) input; | |||
} | |||
}).toList(); | |||
return added.stream() | |||
.filter(input -> input.getClass().getSimpleName().contains(type.getSimpleName())) | |||
.map(input -> (T) input) | |||
.collect(Collectors.toList()); | |||
} | |||
} | |||
@@ -67,7 +67,7 @@ public class CrossProjectDuplicateTest { | |||
@Test | |||
public void hashcode_depends_on_file_and_TextBlock() { | |||
TextBlock textBlock = new TextBlock(1, 2); | |||
assertThat(new CrossProjectDuplicate(FILE_KEY_1, textBlock).hashCode()).isEqualTo(new CrossProjectDuplicate(FILE_KEY_1, textBlock).hashCode()); | |||
assertThat(new CrossProjectDuplicate(FILE_KEY_1, textBlock)).hasSameHashCodeAs(new CrossProjectDuplicate(FILE_KEY_1, textBlock)); | |||
assertThat(new CrossProjectDuplicate(FILE_KEY_1, textBlock).hashCode()).isNotEqualTo(new CrossProjectDuplicate(FILE_KEY_2, textBlock).hashCode()); | |||
assertThat(new CrossProjectDuplicate(FILE_KEY_1, textBlock).hashCode()).isNotEqualTo(new CrossProjectDuplicate(FILE_KEY_2, new TextBlock(1, 1)).hashCode()); | |||
@@ -75,7 +75,7 @@ public class CrossProjectDuplicateTest { | |||
@Test | |||
public void verify_toString() { | |||
assertThat(new CrossProjectDuplicate(FILE_KEY_1, new TextBlock(1, 2)).toString()).isEqualTo("CrossProjectDuplicate{fileKey='file key 1', textBlock=TextBlock{start=1, end=2}}"); | |||
assertThat(new CrossProjectDuplicate(FILE_KEY_1, new TextBlock(1, 2))).hasToString("CrossProjectDuplicate{fileKey='file key 1', textBlock=TextBlock{start=1, end=2}}"); | |||
} | |||
} |
@@ -19,13 +19,12 @@ | |||
*/ | |||
package org.sonar.ce.task.projectanalysis.duplication; | |||
import com.google.common.base.Function; | |||
import com.google.common.collect.ArrayListMultimap; | |||
import com.google.common.collect.Multimap; | |||
import java.util.Arrays; | |||
import java.util.Collections; | |||
import java.util.stream.Collectors; | |||
import javax.annotation.CheckForNull; | |||
import javax.annotation.Nonnull; | |||
import org.junit.rules.ExternalResource; | |||
import org.sonar.ce.task.projectanalysis.component.Component; | |||
import org.sonar.ce.task.projectanalysis.component.ComponentProvider; | |||
@@ -34,7 +33,6 @@ import org.sonar.ce.task.projectanalysis.component.TreeRootHolderComponentProvid | |||
import org.sonar.ce.task.projectanalysis.component.TreeRootHolderRule; | |||
import static com.google.common.base.Preconditions.checkArgument; | |||
import static com.google.common.collect.FluentIterable.from; | |||
import static java.util.Objects.requireNonNull; | |||
public class DuplicationRepositoryRule extends ExternalResource implements DuplicationRepository { | |||
@@ -101,7 +99,7 @@ public class DuplicationRepositoryRule extends ExternalResource implements Dupli | |||
component, | |||
new Duplication( | |||
original, | |||
from(Arrays.asList(duplicates)).transform(TextBlockToInnerDuplicate.INSTANCE).toList())); | |||
Arrays.stream(duplicates).map(InnerDuplicate::new).collect(Collectors.toList()))); | |||
return this; | |||
} | |||
@@ -169,14 +167,4 @@ public class DuplicationRepositoryRule extends ExternalResource implements Dupli | |||
requireNonNull(this.componentProvider, "Methods with component reference can not be used unless a TreeRootHolder has been provided when instantiating the rule"); | |||
this.componentProvider.ensureInitialized(); | |||
} | |||
private enum TextBlockToInnerDuplicate implements Function<TextBlock, Duplicate> { | |||
INSTANCE; | |||
@Override | |||
@Nonnull | |||
public Duplicate apply(@Nonnull TextBlock input) { | |||
return new InnerDuplicate(input); | |||
} | |||
} | |||
} |
@@ -154,7 +154,7 @@ public class DuplicationTest { | |||
public void hashcode_is_based_on_original_only() { | |||
Duplication duplication = new Duplication(SOME_ORIGINAL_TEXTBLOCK, Arrays.asList(new InnerDuplicate(TEXT_BLOCK_1))); | |||
assertThat(duplication.hashCode()).isEqualTo(new Duplication(SOME_ORIGINAL_TEXTBLOCK, Arrays.asList(new InnerDuplicate(TEXT_BLOCK_1))).hashCode()); | |||
assertThat(duplication).hasSameHashCodeAs(new Duplication(SOME_ORIGINAL_TEXTBLOCK, Arrays.asList(new InnerDuplicate(TEXT_BLOCK_1)))); | |||
assertThat(duplication.hashCode()).isNotEqualTo(new Duplication(SOME_ORIGINAL_TEXTBLOCK, Arrays.asList(new InnerDuplicate(TEXT_BLOCK_2))).hashCode()); | |||
assertThat(duplication.hashCode()).isNotEqualTo(new Duplication(TEXT_BLOCK_1, Arrays.asList(new InnerDuplicate(SOME_ORIGINAL_TEXTBLOCK))).hashCode()); | |||
} |
@@ -77,7 +77,7 @@ public class InProjectDuplicateTest { | |||
@Test | |||
public void hashcode_depends_on_file_and_TextBlock() { | |||
TextBlock textBlock = new TextBlock(1, 2); | |||
assertThat(new InProjectDuplicate(FILE_1, textBlock).hashCode()).isEqualTo(new InProjectDuplicate(FILE_1, textBlock).hashCode()); | |||
assertThat(new InProjectDuplicate(FILE_1, textBlock)).hasSameHashCodeAs(new InProjectDuplicate(FILE_1, textBlock)); | |||
assertThat(new InProjectDuplicate(FILE_1, textBlock).hashCode()).isNotEqualTo(new InProjectDuplicate(FILE_2, textBlock).hashCode()); | |||
assertThat(new InProjectDuplicate(FILE_1, textBlock).hashCode()).isNotEqualTo(new InProjectDuplicate(FILE_2, new TextBlock(1, 1)).hashCode()); |
@@ -48,11 +48,11 @@ public class InnerDuplicateTest { | |||
@Test | |||
public void hashcode_is_TextBlock_hashcode() { | |||
TextBlock textBlock = new TextBlock(1, 2); | |||
assertThat(new InnerDuplicate(textBlock).hashCode()).isEqualTo(textBlock.hashCode()); | |||
assertThat(new InnerDuplicate(textBlock)).hasSameHashCodeAs(textBlock); | |||
} | |||
@Test | |||
public void verify_toString() { | |||
assertThat(new InnerDuplicate(new TextBlock(1, 2)).toString()).isEqualTo("InnerDuplicate{textBlock=TextBlock{start=1, end=2}}"); | |||
assertThat(new InnerDuplicate(new TextBlock(1, 2))).hasToString("InnerDuplicate{textBlock=TextBlock{start=1, end=2}}"); | |||
} | |||
} |
@@ -68,8 +68,8 @@ public class TextBlockTest { | |||
@Test | |||
public void hashcode_is_based__on_start_and_end() { | |||
assertThat(new TextBlock(15, 15).hashCode()).isEqualTo(new TextBlock(15, 15).hashCode()); | |||
assertThat(new TextBlock(15, 300).hashCode()).isEqualTo(new TextBlock(15, 300).hashCode()); | |||
assertThat(new TextBlock(15, 15)).hasSameHashCodeAs(new TextBlock(15, 15)); | |||
assertThat(new TextBlock(15, 300)).hasSameHashCodeAs(new TextBlock(15, 300)); | |||
assertThat(new TextBlock(15, 300).hashCode()).isNotEqualTo(new TextBlock(15, 15).hashCode()); | |||
} | |||
@@ -90,7 +90,7 @@ public class TextBlockTest { | |||
@Test | |||
public void verify_toString() { | |||
assertThat(new TextBlock(13, 400).toString()).isEqualTo("TextBlock{start=13, end=400}"); | |||
assertThat(new TextBlock(13, 400)).hasToString("TextBlock{start=13, end=400}"); | |||
} | |||
} |
@@ -63,8 +63,9 @@ public class EventTest { | |||
@Test | |||
public void same_name_and_category_make_equal_events() { | |||
Event source = Event.createAlert(SOME_NAME, null, null); | |||
assertThat(source).isEqualTo(Event.createAlert(SOME_NAME, null, null)); | |||
assertThat(source).isEqualTo(source); | |||
assertThat(source).isNotEqualTo(null); | |||
assertThat(source) | |||
.isEqualTo(Event.createAlert(SOME_NAME, null, null)) | |||
.isEqualTo(source) | |||
.isNotNull(); | |||
} | |||
} |
@@ -348,7 +348,7 @@ public class FileMoveDetectionStepTest { | |||
assertThat(movedFilesRepository.getComponentsWithOriginal()).isEmpty(); | |||
assertThat(scoreMatrixDumper.scoreMatrix.getMaxScore()) | |||
.isGreaterThan(0) | |||
.isPositive() | |||
.isLessThan(MIN_REQUIRED_SCORE); | |||
assertThat(addedFileRepository.getComponents()).contains(file2); | |||
verifyStatistics(context, 1, 1, 1, 0); |
@@ -75,6 +75,6 @@ public class MatchTest { | |||
@Test | |||
public void toString_prints_both_properties() { | |||
assertThat(underTest.toString()).isEqualTo("{key=>reportKey}"); | |||
assertThat(underTest).hasToString("{key=>reportKey}"); | |||
} | |||
} |
@@ -72,7 +72,7 @@ public class LongValueTest { | |||
private static void verifyUnsetVariationValue(LongValue variationValue) { | |||
assertThat(variationValue.isSet()).isFalse(); | |||
assertThat(variationValue.getValue()).isEqualTo(0L); | |||
assertThat(variationValue.getValue()).isZero(); | |||
} | |||
private static void verifySetVariationValue(LongValue variationValue, long expected) { |
@@ -52,14 +52,14 @@ public class CoverageUtilsTest { | |||
@Test | |||
public void getLongMeasureValue_returns_0_if_measure_does_not_exist() { | |||
assertThat(getLongMeasureValue(fileAggregateContext, SOME_METRIC_KEY)).isEqualTo(0L); | |||
assertThat(getLongMeasureValue(fileAggregateContext, SOME_METRIC_KEY)).isZero(); | |||
} | |||
@Test | |||
public void getLongMeasureValue_returns_0_if_measure_is_NO_VALUE() { | |||
fileAggregateContext.put(SOME_METRIC_KEY, newMeasureBuilder().createNoValue()); | |||
assertThat(getLongMeasureValue(fileAggregateContext, SOME_METRIC_KEY)).isEqualTo(0L); | |||
assertThat(getLongMeasureValue(fileAggregateContext, SOME_METRIC_KEY)).isZero(); | |||
} | |||
@Test |
@@ -78,10 +78,10 @@ public class DebtCalculatorTest { | |||
public void copy_effort_for_external_issues() { | |||
issue.setGap(null); | |||
issue.setIsFromExternalRuleEngine(true); | |||
issue.setEffort(Duration.create(20l)); | |||
issue.setEffort(Duration.create(20L)); | |||
rule.setFunction(null); | |||
assertThat(underTest.calculate(issue).toMinutes()).isEqualTo(20l); | |||
assertThat(underTest.calculate(issue).toMinutes()).isEqualTo(20L); | |||
} | |||
@Test |
@@ -40,13 +40,13 @@ public class NewAdHocRuleTest { | |||
NewAdHocRule adHocRule2 = new NewAdHocRule(ScannerReport.ExternalIssue.newBuilder().setEngineId("eslint").setRuleId("no-cond-assign").build()); | |||
NewAdHocRule anotherAdHocRule = new NewAdHocRule(ScannerReport.ExternalIssue.newBuilder().setEngineId("eslint").setRuleId("another").build()); | |||
assertThat(adHocRule1).isEqualTo(adHocRule1); | |||
assertThat(adHocRule1).isEqualTo(adHocRule2); | |||
assertThat(adHocRule1).isNotEqualTo(null); | |||
assertThat(adHocRule1).isNotEqualTo(anotherAdHocRule); | |||
assertThat(adHocRule1.hashCode()).isEqualTo(adHocRule1.hashCode()); | |||
assertThat(adHocRule1.hashCode()).isEqualTo(adHocRule2.hashCode()); | |||
assertThat(adHocRule1) | |||
.isEqualTo(adHocRule1) | |||
.isEqualTo(adHocRule2) | |||
.isNotNull() | |||
.isNotEqualTo(anotherAdHocRule) | |||
.hasSameHashCodeAs(adHocRule1) | |||
.hasSameHashCodeAs(adHocRule2); | |||
assertThat(adHocRule1.hashCode()).isNotEqualTo(anotherAdHocRule.hashCode()); | |||
} | |||
} |
@@ -231,7 +231,7 @@ public class TrackerRawInputFactoryTest { | |||
.setEngineId("eslint") | |||
.setRuleId("S001") | |||
.setSeverity(Constants.Severity.BLOCKER) | |||
.setEffort(20l) | |||
.setEffort(20L) | |||
.setType(issueType) | |||
.build(); | |||
reportReader.putExternalIssues(FILE.getReportAttributes().getRef(), asList(reportIssue)); | |||
@@ -245,7 +245,7 @@ public class TrackerRawInputFactoryTest { | |||
assertThat(issue.ruleKey()).isEqualTo(RuleKey.of("external_eslint", "S001")); | |||
assertThat(issue.severity()).isEqualTo(Severity.BLOCKER); | |||
assertThat(issue.line()).isEqualTo(2); | |||
assertThat(issue.effort()).isEqualTo(Duration.create(20l)); | |||
assertThat(issue.effort()).isEqualTo(Duration.create(20L)); | |||
assertThat(issue.message()).isEqualTo("the message"); | |||
assertThat(issue.type()).isEqualTo(expectedRuleType); | |||
@@ -288,7 +288,7 @@ public class TrackerRawInputFactoryTest { | |||
assertThat(issue.ruleKey()).isEqualTo(RuleKey.of("external_eslint", "S001")); | |||
assertThat(issue.severity()).isEqualTo(Severity.BLOCKER); | |||
assertThat(issue.line()).isEqualTo(2); | |||
assertThat(issue.effort()).isEqualTo(Duration.create(0l)); | |||
assertThat(issue.effort()).isEqualTo(Duration.create(0L)); | |||
assertThat(issue.message()).isEqualTo("the message"); | |||
assertThat(issue.type()).isEqualTo(expectedRuleType); | |||
@@ -61,7 +61,7 @@ public class IssuePatternTest { | |||
public void test_to_string() { | |||
IssuePattern pattern = new IssuePattern("*", "checkstyle:*"); | |||
assertThat(pattern.toString()).isEqualTo( | |||
assertThat(pattern).hasToString( | |||
"IssuePattern{componentPattern=*, rulePattern=checkstyle:*}"); | |||
} | |||
} |
@@ -151,7 +151,7 @@ public class HandleUnanalyzedLanguagesStepTest { | |||
"1 unanalyzed C++ file was detected in this project during the last analysis. C++ cannot be analyzed with your current SonarQube edition. Please" + | |||
" consider <a target=\"_blank\" href=\"https://www.sonarqube.org/trial-request/developer-edition/?referrer=sonarqube-cpp\">upgrading to Developer" + | |||
" Edition</a> to find Bugs, Code Smells, Vulnerabilities and Security Hotspots in this file."); | |||
assertThat(measureRepository.getAddedRawMeasure(PROJECT_REF, UNANALYZED_CPP_KEY).get().getIntValue()).isEqualTo(1); | |||
assertThat(measureRepository.getAddedRawMeasure(PROJECT_REF, UNANALYZED_CPP_KEY).get().getIntValue()).isOne(); | |||
assertThat(measureRepository.getAddedRawMeasure(PROJECT_REF, UNANALYZED_C_KEY)).isEmpty(); | |||
} | |||
@@ -40,14 +40,14 @@ public class LanguageRepositoryImplTest { | |||
@Test | |||
public void find_on_empty_LanguageRepository_returns_absent() { | |||
assertThat(new LanguageRepositoryImpl().find(ANY_KEY).isPresent()).isFalse(); | |||
assertThat(new LanguageRepositoryImpl().find(ANY_KEY)).isEmpty(); | |||
} | |||
@Test | |||
public void find_by_key_returns_the_same_object() { | |||
LanguageRepositoryImpl languageRepository = new LanguageRepositoryImpl(SOME_LANGUAGE); | |||
Optional<Language> language = languageRepository.find(SOME_LANGUAGE_KEY); | |||
assertThat(language.isPresent()).isTrue(); | |||
assertThat(language).isPresent(); | |||
assertThat(language.get()).isSameAs(SOME_LANGUAGE); | |||
} | |||
@@ -55,7 +55,7 @@ public class LanguageRepositoryImplTest { | |||
public void find_by_other_key_returns_absent() { | |||
LanguageRepositoryImpl languageRepository = new LanguageRepositoryImpl(SOME_LANGUAGE); | |||
Optional<Language> language = languageRepository.find(ANY_KEY); | |||
assertThat(language.isPresent()).isFalse(); | |||
assertThat(language).isEmpty(); | |||
} | |||
private static Language createLanguage(final String key, final String nameSuffix) { |
@@ -141,7 +141,7 @@ public class BatchMeasureToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Int_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_INT_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -153,7 +153,7 @@ public class BatchMeasureToMeasureTest { | |||
Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_INT_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.INT); | |||
assertThat(measure.get().getIntValue()).isEqualTo(10); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); | |||
@@ -163,15 +163,15 @@ public class BatchMeasureToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Long_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_LONG_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@Test | |||
public void toMeasure_returns_long_part_of_value_in_dto_for_Long_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(ScannerReport.Measure.newBuilder().setLongValue(LongValue.newBuilder().setValue(15l)).build(), SOME_LONG_METRIC); | |||
Optional<Measure> measure = underTest.toMeasure(ScannerReport.Measure.newBuilder().setLongValue(LongValue.newBuilder().setValue(15L)).build(), SOME_LONG_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG); | |||
assertThat(measure.get().getLongValue()).isEqualTo(15); | |||
} | |||
@@ -179,12 +179,12 @@ public class BatchMeasureToMeasureTest { | |||
@Test | |||
public void toMeasure_maps_data_and_alert_properties_in_dto_for_Long_Metric() { | |||
ScannerReport.Measure batchMeasure = ScannerReport.Measure.newBuilder() | |||
.setLongValue(LongValue.newBuilder().setValue(10l).setData(SOME_DATA)) | |||
.setLongValue(LongValue.newBuilder().setValue(10L).setData(SOME_DATA)) | |||
.build(); | |||
Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_LONG_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG); | |||
assertThat(measure.get().getLongValue()).isEqualTo(10); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); | |||
@@ -194,7 +194,7 @@ public class BatchMeasureToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Double_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_DOUBLE_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -206,7 +206,7 @@ public class BatchMeasureToMeasureTest { | |||
Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_DOUBLE_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.DOUBLE); | |||
assertThat(measure.get().getDoubleValue()).isEqualTo(10.6395d); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); | |||
@@ -216,7 +216,7 @@ public class BatchMeasureToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Boolean_metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_BOOLEAN_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -229,7 +229,7 @@ public class BatchMeasureToMeasureTest { | |||
private void verify_toMeasure_returns_false_value_if_dto_has_invalid_value_for_Boolean_metric(boolean expected) { | |||
Optional<Measure> measure = underTest.toMeasure(ScannerReport.Measure.newBuilder().setBooleanValue(BoolValue.newBuilder().setValue(expected)).build(), SOME_BOOLEAN_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN); | |||
assertThat(measure.get().getBooleanValue()).isEqualTo(expected); | |||
} | |||
@@ -241,7 +241,7 @@ public class BatchMeasureToMeasureTest { | |||
Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_BOOLEAN_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN); | |||
assertThat(measure.get().getBooleanValue()).isTrue(); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); | |||
@@ -251,7 +251,7 @@ public class BatchMeasureToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_String_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_STRING_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -263,7 +263,7 @@ public class BatchMeasureToMeasureTest { | |||
Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_STRING_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.STRING); | |||
assertThat(measure.get().getStringValue()).isEqualTo(SOME_DATA); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); |
@@ -127,7 +127,7 @@ public class LiveMeasureDtoToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Int_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_INT_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -135,16 +135,16 @@ public class LiveMeasureDtoToMeasureTest { | |||
public void toMeasure_returns_int_part_of_value_in_dto_for_Int_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(new LiveMeasureDto().setValue(1.5d), SOME_INT_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.INT); | |||
assertThat(measure.get().getIntValue()).isEqualTo(1); | |||
assertThat(measure.get().getIntValue()).isOne(); | |||
} | |||
@Test | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Long_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_LONG_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -152,16 +152,16 @@ public class LiveMeasureDtoToMeasureTest { | |||
public void toMeasure_returns_long_part_of_value_in_dto_for_Long_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(new LiveMeasureDto().setValue(1.5d), SOME_LONG_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG); | |||
assertThat(measure.get().getLongValue()).isEqualTo(1); | |||
assertThat(measure.get().getLongValue()).isOne(); | |||
} | |||
@Test | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Double_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_DOUBLE_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -169,7 +169,7 @@ public class LiveMeasureDtoToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Boolean_metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_BOOLEAN_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -177,7 +177,7 @@ public class LiveMeasureDtoToMeasureTest { | |||
public void toMeasure_returns_false_value_if_dto_has_invalid_value_for_Boolean_metric() { | |||
Optional<Measure> measure = underTest.toMeasure(new LiveMeasureDto().setValue(1.987d), SOME_BOOLEAN_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN); | |||
assertThat(measure.get().getBooleanValue()).isFalse(); | |||
} | |||
@@ -186,7 +186,7 @@ public class LiveMeasureDtoToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_String_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_STRING_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -211,7 +211,7 @@ public class LiveMeasureDtoToMeasureTest { | |||
@Test | |||
@UseDataProvider("all_types_LiveMeasureDtos") | |||
public void toMeasure_creates_MeasureVariation_and_maps_the_right_one(LiveMeasureDto builder, Metric metric) { | |||
assertThat(underTest.toMeasure(builder.setVariation(1d), metric).get().getVariation()).isEqualTo(1); | |||
assertThat(underTest.toMeasure(builder.setVariation(1d), metric).get().getVariation()).isOne(); | |||
} | |||
@Test |
@@ -141,7 +141,7 @@ public class MapBasedRawMeasureRepositoryTest { | |||
private static final List<Measure> MEASURES = ImmutableList.of( | |||
Measure.newMeasureBuilder().create(1), | |||
Measure.newMeasureBuilder().create(1l), | |||
Measure.newMeasureBuilder().create(1L), | |||
Measure.newMeasureBuilder().create(1d, 1), | |||
Measure.newMeasureBuilder().create(true), | |||
Measure.newMeasureBuilder().create(false), |
@@ -152,7 +152,7 @@ public class MeasureDtoToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Int_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_INT_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -160,9 +160,9 @@ public class MeasureDtoToMeasureTest { | |||
public void toMeasure_returns_int_part_of_value_in_dto_for_Int_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(new MeasureDto().setValue(1.5d), SOME_INT_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.INT); | |||
assertThat(measure.get().getIntValue()).isEqualTo(1); | |||
assertThat(measure.get().getIntValue()).isOne(); | |||
} | |||
@Test | |||
@@ -171,7 +171,7 @@ public class MeasureDtoToMeasureTest { | |||
Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_INT_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.INT); | |||
assertThat(measure.get().getIntValue()).isEqualTo(10); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); | |||
@@ -183,7 +183,7 @@ public class MeasureDtoToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Long_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_LONG_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -191,9 +191,9 @@ public class MeasureDtoToMeasureTest { | |||
public void toMeasure_returns_long_part_of_value_in_dto_for_Long_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(new MeasureDto().setValue(1.5d), SOME_LONG_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG); | |||
assertThat(measure.get().getLongValue()).isEqualTo(1); | |||
assertThat(measure.get().getLongValue()).isOne(); | |||
} | |||
@Test | |||
@@ -202,7 +202,7 @@ public class MeasureDtoToMeasureTest { | |||
Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_LONG_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG); | |||
assertThat(measure.get().getLongValue()).isEqualTo(10); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); | |||
@@ -214,7 +214,7 @@ public class MeasureDtoToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Double_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_DOUBLE_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -224,7 +224,7 @@ public class MeasureDtoToMeasureTest { | |||
Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_DOUBLE_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.DOUBLE); | |||
assertThat(measure.get().getDoubleValue()).isEqualTo(10.6395d); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); | |||
@@ -236,7 +236,7 @@ public class MeasureDtoToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_Boolean_metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_BOOLEAN_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -244,7 +244,7 @@ public class MeasureDtoToMeasureTest { | |||
public void toMeasure_returns_false_value_if_dto_has_invalid_value_for_Boolean_metric() { | |||
Optional<Measure> measure = underTest.toMeasure(new MeasureDto().setValue(1.987d), SOME_BOOLEAN_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN); | |||
assertThat(measure.get().getBooleanValue()).isFalse(); | |||
} | |||
@@ -255,7 +255,7 @@ public class MeasureDtoToMeasureTest { | |||
Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_BOOLEAN_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN); | |||
assertThat(measure.get().getBooleanValue()).isTrue(); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); | |||
@@ -267,7 +267,7 @@ public class MeasureDtoToMeasureTest { | |||
public void toMeasure_returns_no_value_if_dto_has_no_value_for_String_Metric() { | |||
Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_STRING_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE); | |||
} | |||
@@ -277,7 +277,7 @@ public class MeasureDtoToMeasureTest { | |||
Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_STRING_METRIC); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.STRING); | |||
assertThat(measure.get().getStringValue()).isEqualTo(SOME_DATA); | |||
assertThat(measure.get().getData()).isEqualTo(SOME_DATA); | |||
@@ -306,7 +306,7 @@ public class MeasureDtoToMeasureTest { | |||
@Test | |||
@UseDataProvider("all_types_MeasureDtos") | |||
public void toMeasure_creates_MeasureVariation_and_maps_the_right_one(MeasureDto builder, Metric metric) { | |||
assertThat(underTest.toMeasure(builder.setVariation(1d), metric).get().getVariation()).isEqualTo(1); | |||
assertThat(underTest.toMeasure(builder.setVariation(1d), metric).get().getVariation()).isOne(); | |||
} | |||
@Test |
@@ -215,7 +215,7 @@ public class MeasureRepositoryImplTest { | |||
private static final List<Measure> MEASURES = ImmutableList.of( | |||
Measure.newMeasureBuilder().create(1), | |||
Measure.newMeasureBuilder().create(1l), | |||
Measure.newMeasureBuilder().create(1L), | |||
Measure.newMeasureBuilder().create(1d, 1), | |||
Measure.newMeasureBuilder().create(true), | |||
Measure.newMeasureBuilder().create(false), | |||
@@ -272,7 +272,7 @@ public class MeasureRepositoryImplTest { | |||
} | |||
private Measure getSomeMeasureByValueType(final Metric.MetricType metricType) { | |||
return from(MEASURES).filter(input -> input.getValueType() == metricType.getValueType()).first().get(); | |||
return MEASURES.stream().filter(input -> input.getValueType() == metricType.getValueType()).findFirst().get(); | |||
} | |||
@Test |
@@ -37,7 +37,7 @@ import static org.sonar.ce.task.projectanalysis.measure.Measure.newMeasureBuilde | |||
public class MeasureTest { | |||
private static final Measure INT_MEASURE = newMeasureBuilder().create(1); | |||
private static final Measure LONG_MEASURE = newMeasureBuilder().create(1l); | |||
private static final Measure LONG_MEASURE = newMeasureBuilder().create(1L); | |||
private static final Measure DOUBLE_MEASURE = newMeasureBuilder().create(1d, 1); | |||
private static final Measure STRING_MEASURE = newMeasureBuilder().create("some_sT ring"); | |||
private static final Measure TRUE_MEASURE = newMeasureBuilder().create(true); | |||
@@ -132,7 +132,7 @@ public class MeasureTest { | |||
@Test | |||
public void getIntValue_returns_value_for_INT_value_type() { | |||
assertThat(INT_MEASURE.getIntValue()).isEqualTo(1); | |||
assertThat(INT_MEASURE.getIntValue()).isOne(); | |||
} | |||
@Test | |||
@@ -144,7 +144,7 @@ public class MeasureTest { | |||
@Test | |||
public void getLongValue_returns_value_for_LONG_value_type() { | |||
assertThat(LONG_MEASURE.getLongValue()).isEqualTo(1); | |||
assertThat(LONG_MEASURE.getLongValue()).isOne(); | |||
} | |||
@Test |
@@ -71,12 +71,12 @@ public class QualityGateStatusTest { | |||
assertThat(status).isEqualTo(new QualityGateStatus(level, null)); | |||
assertThat(status).isNotEqualTo(new QualityGateStatus(level, "bar")); | |||
assertThat(status).isNotEqualTo(new QualityGateStatus(level, "")); | |||
assertThat(status).isNotEqualTo(null); | |||
assertThat(status).isNotNull(); | |||
} | |||
} | |||
@Test | |||
public void verify_toString() { | |||
assertThat(new QualityGateStatus(Measure.Level.OK, "foo").toString()).isEqualTo("QualityGateStatus{status=OK, text=foo}"); | |||
assertThat(new QualityGateStatus(Measure.Level.OK, "foo")).hasToString("QualityGateStatus{status=OK, text=foo}"); | |||
} | |||
} |
@@ -49,13 +49,13 @@ public class PeriodTest { | |||
public void equals_is_done_on_all_fields() { | |||
Period period = new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034400000L); | |||
assertThat(period).isEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034400000L)); | |||
assertThat(period).isNotEqualTo(null); | |||
assertThat(period).isNotEqualTo("sdsd"); | |||
assertThat(period).isNotEqualTo(new Period(NewCodePeriodType.PREVIOUS_VERSION.name(), "2.3", 1420034400000L)); | |||
assertThat(period).isNotEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.4", 1420034400000L)); | |||
assertThat(period).isNotEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034410000L)); | |||
assertThat(period) | |||
.isEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034400000L)) | |||
.isNotNull() | |||
.isNotEqualTo("sdsd") | |||
.isNotEqualTo(new Period(NewCodePeriodType.PREVIOUS_VERSION.name(), "2.3", 1420034400000L)) | |||
.isNotEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.4", 1420034400000L)) | |||
.isNotEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034410000L)); | |||
} | |||
} |
@@ -109,7 +109,7 @@ public class ConditionEvaluatorTest { | |||
@Test | |||
public void getLevel_throws_IEA_if_error_threshold_is_not_parsable_long() { | |||
Metric metric = createMetric(WORK_DUR); | |||
Measure measure = newMeasureBuilder().create(60l, null); | |||
Measure measure = newMeasureBuilder().create(60L, null); | |||
assertThatThrownBy(() -> underTest.evaluate(createCondition(metric, LESS_THAN, "polop"), measure)) | |||
.isInstanceOf(IllegalArgumentException.class) |
@@ -68,8 +68,8 @@ public class ConditionStatusTest { | |||
@Test | |||
public void verify_toString() { | |||
assertThat(ConditionStatus.create(OK, SOME_VALUE).toString()).isEqualTo("ConditionStatus{status=OK, value='value'}"); | |||
assertThat(ConditionStatus.NO_VALUE_STATUS.toString()).isEqualTo("ConditionStatus{status=NO_VALUE, value='null'}"); | |||
assertThat(ConditionStatus.create(OK, SOME_VALUE)).hasToString("ConditionStatus{status=OK, value='value'}"); | |||
assertThat(ConditionStatus.NO_VALUE_STATUS).hasToString("ConditionStatus{status=NO_VALUE, value='null'}"); | |||
} | |||
@Test |
@@ -69,7 +69,7 @@ public class NewMaintainabilityMeasuresVisitorTest { | |||
private static final double[] RATING_GRID = new double[] {0.1, 0.2, 0.5, 1}; | |||
private static final String LANGUAGE_1_KEY = "language 1 key"; | |||
private static final long LANGUAGE_1_DEV_COST = 30l; | |||
private static final long LANGUAGE_1_DEV_COST = 30L; | |||
private static final int ROOT_REF = 1; | |||
private static final int LANGUAGE_1_FILE_REF = 11111; | |||
private static final Offset<Double> VARIATION_COMPARISON_OFFSET = Offset.offset(0.01); |
@@ -72,8 +72,8 @@ import static org.sonar.server.measure.Rating.E; | |||
public class NewReliabilityAndSecurityRatingMeasuresVisitorTest { | |||
private static final long LEAK_PERIOD_SNAPSHOT_IN_MILLISEC = 12323l; | |||
private static final Date DEFAULT_ISSUE_CREATION_DATE = new Date(1000l); | |||
private static final long LEAK_PERIOD_SNAPSHOT_IN_MILLISEC = 12323L; | |||
private static final Date DEFAULT_ISSUE_CREATION_DATE = new Date(1000L); | |||
private static final Date BEFORE_LEAK_PERIOD_DATE = new Date(LEAK_PERIOD_SNAPSHOT_IN_MILLISEC - 5000L); | |||
private static final Date AFTER_LEAK_PERIOD_DATE = new Date(LEAK_PERIOD_SNAPSHOT_IN_MILLISEC + 5000L); | |||
@@ -74,8 +74,8 @@ public class NewSecurityReviewMeasuresVisitorTest { | |||
private static final Offset<Double> VARIATION_COMPARISON_OFFSET = Offset.offset(0.01); | |||
private static final long LEAK_PERIOD_SNAPSHOT_IN_MILLISEC = 12323l; | |||
private static final Date DEFAULT_CREATION_DATE = new Date(1000l); | |||
private static final long LEAK_PERIOD_SNAPSHOT_IN_MILLISEC = 12323L; | |||
private static final Date DEFAULT_CREATION_DATE = new Date(1000L); | |||
private static final Date BEFORE_LEAK_PERIOD_DATE = new Date(LEAK_PERIOD_SNAPSHOT_IN_MILLISEC - 5000L); | |||
private static final Date AFTER_LEAK_PERIOD_DATE = new Date(LEAK_PERIOD_SNAPSHOT_IN_MILLISEC + 5000L); | |||
@@ -251,7 +251,7 @@ public class ReliabilityAndSecurityRatingMeasuresVisitorTest { | |||
.setKey(Uuids.create()) | |||
.setSeverity(severity) | |||
.setType(type) | |||
.setCreationDate(new Date(1000l)); | |||
.setCreationDate(new Date(1000L)); | |||
} | |||
} |
@@ -45,7 +45,7 @@ public class ActiveRulesHolderImplTest { | |||
public void get_inactive_rule() { | |||
underTest.set(Collections.emptyList()); | |||
Optional<ActiveRule> activeRule = underTest.get(RULE_KEY); | |||
assertThat(activeRule.isPresent()).isFalse(); | |||
assertThat(activeRule).isEmpty(); | |||
} | |||
@Test | |||
@@ -53,7 +53,7 @@ public class ActiveRulesHolderImplTest { | |||
underTest.set(asList(new ActiveRule(RULE_KEY, Severity.BLOCKER, Collections.emptyMap(), SOME_DATE, PLUGIN_KEY, QP_KEY))); | |||
Optional<ActiveRule> activeRule = underTest.get(RULE_KEY); | |||
assertThat(activeRule.isPresent()).isTrue(); | |||
assertThat(activeRule).isPresent(); | |||
assertThat(activeRule.get().getRuleKey()).isEqualTo(RULE_KEY); | |||
assertThat(activeRule.get().getSeverity()).isEqualTo(Severity.BLOCKER); | |||
} |
@@ -26,7 +26,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; | |||
public class ChangesetTest { | |||
@Test | |||
public void create_changeset() { | |||
Changeset underTest = Changeset.newChangesetBuilder() | |||
@@ -78,7 +77,7 @@ public class ChangesetTest { | |||
.setRevision("rev-1") | |||
.build(); | |||
assertThat(underTest.toString()).isEqualTo("Changeset{revision='rev-1', author='john', date=123456789}"); | |||
assertThat(underTest).hasToString("Changeset{revision='rev-1', author='john', date=123456789}"); | |||
} | |||
@Test | |||
@@ -103,14 +102,15 @@ public class ChangesetTest { | |||
.setRevision("rev-2") | |||
.build(); | |||
assertThat(changeset).isEqualTo(changeset); | |||
assertThat(changeset).isEqualTo(sameChangeset); | |||
assertThat(changeset).isNotEqualTo(anotherChangesetWithSameRevision); | |||
assertThat(changeset).isNotEqualTo(anotherChangeset); | |||
assertThat(changeset.hashCode()).isEqualTo(changeset.hashCode()); | |||
assertThat(changeset.hashCode()).isEqualTo(sameChangeset.hashCode()); | |||
assertThat(changeset.hashCode()).isNotEqualTo(anotherChangesetWithSameRevision.hashCode()); | |||
assertThat(changeset.hashCode()).isNotEqualTo(anotherChangeset.hashCode()); | |||
assertThat(changeset) | |||
.isEqualTo(changeset) | |||
.isEqualTo(sameChangeset) | |||
.isNotEqualTo(anotherChangesetWithSameRevision) | |||
.isNotEqualTo(anotherChangeset) | |||
.hasSameHashCodeAs(changeset) | |||
.hasSameHashCodeAs(sameChangeset); | |||
assertThat(changeset.hashCode()) | |||
.isNotEqualTo(anotherChangesetWithSameRevision.hashCode()) | |||
.isNotEqualTo(anotherChangeset.hashCode()); | |||
} | |||
} |
@@ -102,7 +102,7 @@ public class ScmInfoImplTest { | |||
public void test_to_string() { | |||
ScmInfo scmInfo = createScmInfoWithTwoChangestOnFourLines(); | |||
assertThat(scmInfo.toString()).isEqualTo("ScmInfoImpl{" + | |||
assertThat(scmInfo).hasToString("ScmInfoImpl{" + | |||
"latestChangeset=Changeset{revision='rev-2', author='henry', date=1234567810}, " + | |||
"lineChangesets={" + | |||
"1=Changeset{revision='rev-1', author='john', date=123456789}, " + |
@@ -218,12 +218,12 @@ public class LastCommitVisitorTest { | |||
underTest.visit(file); | |||
Optional<Measure> measure = measureRepository.getAddedRawMeasure(FILE_1_REF, LAST_COMMIT_DATE_KEY); | |||
assertThat(measure.isPresent()).isFalse(); | |||
assertThat(measure).isEmpty(); | |||
} | |||
private void assertDate(int componentRef, long expectedDate) { | |||
Optional<Measure> measure = measureRepository.getAddedRawMeasure(componentRef, LAST_COMMIT_DATE_KEY); | |||
assertThat(measure.isPresent()).isTrue(); | |||
assertThat(measure).isPresent(); | |||
assertThat(measure.get().getLongValue()).isEqualTo(expectedDate); | |||
} | |||
@@ -104,7 +104,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getProjectUuid()).isEqualTo(PROJECT_UUID); | |||
assertThat(fileSourceDto.getFileUuid()).isEqualTo(FILE1_UUID); | |||
@@ -117,7 +117,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
DbFileSources.Data data = fileSourceDto.getSourceData(); | |||
assertThat(data.getLinesCount()).isEqualTo(2); | |||
assertThat(data.getLines(0).getLine()).isEqualTo(1); | |||
assertThat(data.getLines(0).getLine()).isOne(); | |||
assertThat(data.getLines(0).getSource()).isEqualTo("line1"); | |||
assertThat(data.getLines(1).getLine()).isEqualTo(2); | |||
assertThat(data.getLines(1).getSource()).isEqualTo("line2"); | |||
@@ -132,7 +132,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getLineHashes()).containsExactly("137f72c3708c6bd0de00a0e5a69c699b", "e6251bcf1a7dc3ba5e7933e325bbe605"); | |||
assertThat(fileSourceDto.getSrcHash()).isEqualTo("ee5a58024a155466b43bc559d953e018"); | |||
@@ -153,7 +153,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getSourceData()).isEqualTo(dbData); | |||
verify(fileSourceDataWarnings).commitWarnings(); | |||
@@ -176,7 +176,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getSourceData()).isEqualTo(dbData); | |||
assertThat(fileSourceDto.getRevision()).isNull(); | |||
@@ -201,7 +201,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
DbFileSources.Data data = fileSourceDto.getSourceData(); | |||
@@ -233,7 +233,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
DbFileSources.Data data = fileSourceDto.getSourceData(); | |||
assertThat(data).isEqualTo(dbData); | |||
@@ -257,7 +257,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getSourceData()).isEqualTo(dbData); | |||
verify(fileSourceDataWarnings).commitWarnings(); | |||
@@ -274,7 +274,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getSourceData()).isEqualTo(dbData); | |||
verify(fileSourceDataWarnings).commitWarnings(); | |||
@@ -313,7 +313,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getSrcHash()).isEqualTo("sourceHash"); | |||
assertThat(fileSourceDto.getLineHashes()).isEqualTo(Collections.singletonList("lineHash")); | |||
@@ -359,7 +359,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getCreatedAt()).isEqualTo(past); | |||
assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW); | |||
@@ -377,7 +377,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getCreatedAt()).isEqualTo(PAST); | |||
assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW); | |||
@@ -402,7 +402,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("file_sources")).isOne(); | |||
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID); | |||
assertThat(fileSourceDto.getCreatedAt()).isEqualTo(PAST); | |||
assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW); |
@@ -65,13 +65,13 @@ public class ReportIteratorTest { | |||
@Test | |||
public void read_report() { | |||
underTest = new ReportIterator<>(file, ScannerReport.LineCoverage.parser()); | |||
assertThat(underTest.next().getLine()).isEqualTo(1); | |||
assertThat(underTest.next().getLine()).isOne(); | |||
} | |||
@Test | |||
public void do_not_fail_when_calling_has_next_with_iterator_already_closed() { | |||
underTest = new ReportIterator<>(file, ScannerReport.LineCoverage.parser()); | |||
assertThat(underTest.next().getLine()).isEqualTo(1); | |||
assertThat(underTest.next().getLine()).isOne(); | |||
assertThat(underTest.hasNext()).isFalse(); | |||
underTest.close(); |
@@ -81,7 +81,7 @@ public class SignificantCodeRepositoryTest { | |||
assertThat(underTest.getRangesPerLine(component)).isNotEmpty(); | |||
LineRange[] lines = underTest.getRangesPerLine(component).get(); | |||
assertThat(lines).hasSize(1); | |||
assertThat(lines[0].startOffset()).isEqualTo(1); | |||
assertThat(lines[0].startOffset()).isOne(); | |||
assertThat(lines[0].endOffset()).isEqualTo(2); | |||
} | |||
@@ -41,7 +41,7 @@ public class CoverageLineReaderTest { | |||
DbFileSources.Line.Builder lineBuilder = DbFileSources.Data.newBuilder().addLinesBuilder().setLine(1); | |||
assertThat(computeCoverageLine.read(lineBuilder)).isEmpty(); | |||
assertThat(lineBuilder.getLineHits()).isEqualTo(1); | |||
assertThat(lineBuilder.getLineHits()).isOne(); | |||
assertThat(lineBuilder.getConditions()).isEqualTo(10); | |||
assertThat(lineBuilder.getCoveredConditions()).isEqualTo(2); | |||
} |
@@ -108,8 +108,8 @@ public class ExecuteVisitorsStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(measureRepository.getAddedRawMeasure(FILE_1_REF, TEST_METRIC_KEY).get().getIntValue()).isEqualTo(1); | |||
assertThat(measureRepository.getAddedRawMeasure(FILE_2_REF, TEST_METRIC_KEY).get().getIntValue()).isEqualTo(1); | |||
assertThat(measureRepository.getAddedRawMeasure(FILE_1_REF, TEST_METRIC_KEY).get().getIntValue()).isOne(); | |||
assertThat(measureRepository.getAddedRawMeasure(FILE_2_REF, TEST_METRIC_KEY).get().getIntValue()).isOne(); | |||
assertThat(measureRepository.getAddedRawMeasure(DIRECTORY_REF, TEST_METRIC_KEY).get().getIntValue()).isEqualTo(2); | |||
assertThat(measureRepository.getAddedRawMeasure(ROOT_REF, TEST_METRIC_KEY).get().getIntValue()).isEqualTo(2); | |||
} |
@@ -88,7 +88,7 @@ public class LoadReportAnalysisMetadataHolderStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(analysisMetadataHolder.getRootComponentRef()).isEqualTo(1); | |||
assertThat(analysisMetadataHolder.getRootComponentRef()).isOne(); | |||
} | |||
@Test | |||
@@ -140,7 +140,7 @@ public class LoadReportAnalysisMetadataHolderStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isEqualTo(true); | |||
assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isTrue(); | |||
} | |||
@Test | |||
@@ -152,7 +152,7 @@ public class LoadReportAnalysisMetadataHolderStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isEqualTo(false); | |||
assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isFalse(); | |||
} | |||
@Test | |||
@@ -163,7 +163,7 @@ public class LoadReportAnalysisMetadataHolderStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isEqualTo(false); | |||
assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isFalse(); | |||
} | |||
@Test |
@@ -90,7 +90,7 @@ public class PersistAdHocRulesStepTest extends BaseStepTest { | |||
assertThat(reloaded.getSeverity()).isNull(); | |||
assertThat(reloaded.getName()).isEqualTo("eslint:no-cond-assign"); | |||
assertThat(es.countDocuments(RuleIndexDefinition.TYPE_RULE)).isEqualTo(1L); | |||
assertThat(es.countDocuments(RuleIndexDefinition.TYPE_RULE)).isOne(); | |||
assertThat(es.getDocuments(RuleIndexDefinition.TYPE_RULE).iterator().next().getId()).isEqualTo(reloaded.getUuid()); | |||
} | |||
@@ -100,12 +100,13 @@ public class PersistCrossProjectDuplicationIndexStepTest { | |||
underTest.execute(context); | |||
Map<String, Object> dto = dbTester.selectFirst("select HASH, START_LINE, END_LINE, INDEX_IN_FILE, COMPONENT_UUID, ANALYSIS_UUID from duplications_index"); | |||
assertThat(dto.get("HASH")).isEqualTo(CPD_TEXT_BLOCK.getHash()); | |||
assertThat(dto.get("START_LINE")).isEqualTo(30L); | |||
assertThat(dto.get("END_LINE")).isEqualTo(45L); | |||
assertThat(dto.get("INDEX_IN_FILE")).isEqualTo(0L); | |||
assertThat(dto.get("COMPONENT_UUID")).isEqualTo(FILE_1.getUuid()); | |||
assertThat(dto.get("ANALYSIS_UUID")).isEqualTo(ANALYSIS_UUID); | |||
assertThat(dto) | |||
.containsEntry("HASH", CPD_TEXT_BLOCK.getHash()) | |||
.containsEntry("START_LINE", 30L) | |||
.containsEntry("END_LINE", 45L) | |||
.containsEntry("INDEX_IN_FILE", 0L) | |||
.containsEntry("COMPONENT_UUID", FILE_1.getUuid()) | |||
.containsEntry("ANALYSIS_UUID", ANALYSIS_UUID); | |||
context.getStatistics().assertValue("inserts", 1); | |||
} | |||
@@ -125,7 +125,7 @@ public class PersistEventsStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable(dbTester.getSession(), "events")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable(dbTester.getSession(), "events")).isOne(); | |||
List<EventDto> eventDtos = dbTester.getDbClient().eventDao().selectByComponentUuid(dbTester.getSession(), ROOT.getUuid()); | |||
assertThat(eventDtos).hasSize(1); | |||
EventDto eventDto = eventDtos.iterator().next(); |
@@ -213,14 +213,14 @@ public class PersistLiveMeasuresStepTest extends BaseStepTest { | |||
Optional<LiveMeasureDto> persisted = dbClient.liveMeasureDao().selectMeasure(db.getSession(), | |||
template.getComponentUuid(), metricRepository.getByUuid(template.getMetricUuid()).getKey()); | |||
assertThat(persisted).isPresent(); | |||
assertThat(persisted.get().getValue()).isEqualTo((double) expectedValue); | |||
assertThat(persisted.get().getValue()).isEqualTo(expectedValue); | |||
} | |||
private void assertThatMeasureHasValue(String componentUuid, Metric metric, int expectedValue) { | |||
Optional<LiveMeasureDto> persisted = dbClient.liveMeasureDao().selectMeasure(db.getSession(), | |||
componentUuid, metric.getKey()); | |||
assertThat(persisted).isPresent(); | |||
assertThat(persisted.get().getValue()).isEqualTo((double) expectedValue); | |||
assertThat(persisted.get().getValue()).isEqualTo(expectedValue); | |||
} | |||
private void assertThatMeasureDoesNotExist(LiveMeasureDto template) { |
@@ -113,7 +113,7 @@ public class PersistMeasuresStepTest extends BaseStepTest { | |||
TestComputationStepContext context = execute(); | |||
// project and dir measures are persisted, but not file measures | |||
assertThat(db.countRowsOfTable("project_measures")).isEqualTo(1); | |||
assertThat(db.countRowsOfTable("project_measures")).isOne(); | |||
assertThat(selectMeasure("project-uuid", STRING_METRIC).get().getData()).isEqualTo("project-value"); | |||
assertThatMeasuresAreNotPersisted("dir-uuid"); | |||
assertThatMeasuresAreNotPersisted("file-uuid"); |
@@ -230,7 +230,7 @@ public class PersistProjectLinksStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(db.countRowsOfTable("project_links")).isEqualTo(1); | |||
assertThat(db.countRowsOfTable("project_links")).isOne(); | |||
} | |||
@Test |
@@ -118,7 +118,7 @@ public class ReportPersistAnalysisStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("snapshots")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("snapshots")).isOne(); | |||
SnapshotDto projectSnapshot = getUnprocessedSnapshot(projectDto.uuid()); | |||
assertThat(projectSnapshot.getUuid()).isEqualTo(ANALYSIS_UUID); |
@@ -102,7 +102,7 @@ public class ViewsPersistAnalysisStepTest extends BaseStepTest { | |||
underTest.execute(new TestComputationStepContext()); | |||
assertThat(dbTester.countRowsOfTable("snapshots")).isEqualTo(1); | |||
assertThat(dbTester.countRowsOfTable("snapshots")).isOne(); | |||
SnapshotDto viewSnapshot = getUnprocessedSnapshot(viewDto.uuid()); | |||
assertThat(viewSnapshot.getUuid()).isEqualTo(ANALYSIS_UUID); |
@@ -39,7 +39,7 @@ public class ProjectExportComputationStepsTest { | |||
@Test | |||
public void count_step_classes() { | |||
assertThat(copyOf(underTest.orderedStepClasses()).size()).isEqualTo(20); | |||
assertThat(copyOf(underTest.orderedStepClasses())).hasSize(20); | |||
} | |||
@Test |
@@ -213,7 +213,7 @@ public class ExportAnalysesStepTest { | |||
private static void assertAnalysis(ProjectDump.Analysis analysis, ComponentDto component, SnapshotDto dto) { | |||
assertThat(analysis.getUuid()).isEqualTo(dto.getUuid()); | |||
assertThat(analysis.getComponentRef()).isEqualTo(1); | |||
assertThat(analysis.getComponentRef()).isOne(); | |||
assertThat(analysis.getDate()).isEqualTo(dto.getCreatedAt()); | |||
assertThat(analysis.getProjectVersion()).isEqualTo(defaultString(dto.getProjectVersion())); | |||
assertThat(analysis.getBuildString()).isEqualTo(defaultString(dto.getBuildString())); |
@@ -136,7 +136,7 @@ public class ExportEventsStepTest { | |||
assertThat(event.getDescription()).isEqualTo("desc"); | |||
assertThat(event.getDate()).isEqualTo(IN_THE_PAST); | |||
assertThat(event.getAnalysisUuid()).isEqualTo(snapshot.getUuid()); | |||
assertThat(event.getComponentRef()).isEqualTo(1); | |||
assertThat(event.getComponentRef()).isOne(); | |||
} | |||
@Test |
@@ -19,9 +19,9 @@ | |||
*/ | |||
package org.sonar.ce.task.projectexport.steps; | |||
import com.google.common.base.Predicate; | |||
import com.sonarsource.governance.projectdump.protobuf.ProjectDump; | |||
import java.util.List; | |||
import java.util.function.Predicate; | |||
import javax.annotation.Nonnull; | |||
import org.junit.Before; | |||
import org.junit.Rule; | |||
@@ -33,7 +33,6 @@ import org.sonar.ce.task.step.TestComputationStepContext; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.metric.MetricDto; | |||
import static com.google.common.collect.FluentIterable.from; | |||
import static org.assertj.core.api.Assertions.assertThat; | |||
import static org.assertj.core.api.Assertions.assertThatThrownBy; | |||
@@ -84,13 +83,13 @@ public class ExportMetricsStepTest { | |||
assertThat(logTester.logs(LoggerLevel.DEBUG)).contains("2 metrics exported"); | |||
List<ProjectDump.Metric> exportedMetrics = dumpWriter.getWrittenMessagesOf(DumpElement.METRICS); | |||
ProjectDump.Metric ncloc = from(exportedMetrics).firstMatch(new HasMetricRefPredicate(0)).get(); | |||
ProjectDump.Metric ncloc = exportedMetrics.stream().filter(input -> input.getRef() == 0).findAny().orElseThrow(); | |||
assertThat(ncloc.getRef()).isZero(); | |||
assertThat(ncloc.getKey()).isEqualTo("ncloc"); | |||
assertThat(ncloc.getName()).isEqualTo("Lines of code"); | |||
ProjectDump.Metric coverage = from(exportedMetrics).firstMatch(new HasMetricRefPredicate(1)).get(); | |||
assertThat(coverage.getRef()).isEqualTo(1); | |||
ProjectDump.Metric coverage = exportedMetrics.stream().filter(input -> input.getRef() == 1).findAny().orElseThrow(); | |||
assertThat(coverage.getRef()).isOne(); | |||
assertThat(coverage.getKey()).isEqualTo("coverage"); | |||
assertThat(coverage.getName()).isEqualTo("Coverage"); | |||
} | |||
@@ -109,17 +108,4 @@ public class ExportMetricsStepTest { | |||
public void test_getDescription() { | |||
assertThat(underTest.getDescription()).isEqualTo("Export metrics"); | |||
} | |||
private static class HasMetricRefPredicate implements Predicate<ProjectDump.Metric> { | |||
private final int ref; | |||
HasMetricRefPredicate(int ref) { | |||
this.ref = ref; | |||
} | |||
@Override | |||
public boolean apply(@Nonnull ProjectDump.Metric input) { | |||
return input.getRef() == ref; | |||
} | |||
} | |||
} |
@@ -41,16 +41,6 @@ public class MeasureAssert extends AbstractAssert<MeasureAssert, Measure> { | |||
return new MeasureAssert(actual == null ? null : actual.orElse(null)); | |||
} | |||
public MeasureAssert hasValueType(Measure.ValueType expected) { | |||
isNotNull(); | |||
if (actual.getValueType() != expected) { | |||
failWithMessage("Expected ValueType of Measure to be <%s> but was <%s>", expected, actual.getValueType()); | |||
} | |||
return this; | |||
} | |||
public MeasureAssert hasValue(int expected) { | |||
isNotNull(); | |||
@@ -169,7 +169,7 @@ public class MeasureRepositoryRule extends ExternalResource implements MeasureRe | |||
@Override | |||
public Map<String, Measure> getRawMeasures(Component component) { | |||
return filterKeys(rawMeasures, hasComponentRef(component)).entrySet().stream() | |||
.collect(Collectors.toMap(k -> k.getKey().getMetricKey(), e -> e.getValue())); | |||
.collect(Collectors.toMap(k -> k.getKey().getMetricKey(), Map.Entry::getValue)); | |||
} | |||
private HasComponentRefPredicate hasComponentRef(Component component) { |
@@ -64,14 +64,15 @@ public class CeTaskComponentTest { | |||
String somethingElse = randomAlphabetic(5); | |||
CeTask.Component underTest = new CeTask.Component(uuid, key, name); | |||
assertThat(underTest).isEqualTo(underTest); | |||
assertThat(underTest).isEqualTo(new CeTask.Component(uuid, key, name)); | |||
assertThat(underTest).isNotEqualTo(null); | |||
assertThat(underTest).isNotEqualTo(new Object()); | |||
assertThat(underTest).isNotEqualTo(new CeTask.Component(somethingElse, key, name)); | |||
assertThat(underTest).isNotEqualTo(new CeTask.Component(uuid, somethingElse, name)); | |||
assertThat(underTest).isNotEqualTo(new CeTask.Component(uuid, key, somethingElse)); | |||
assertThat(underTest).isNotEqualTo(new CeTask.Component(uuid, key, null)); | |||
assertThat(underTest) | |||
.isEqualTo(underTest) | |||
.isEqualTo(new CeTask.Component(uuid, key, name)) | |||
.isNotNull() | |||
.isNotEqualTo(new Object()) | |||
.isNotEqualTo(new CeTask.Component(somethingElse, key, name)) | |||
.isNotEqualTo(new CeTask.Component(uuid, somethingElse, name)) | |||
.isNotEqualTo(new CeTask.Component(uuid, key, somethingElse)) | |||
.isNotEqualTo(new CeTask.Component(uuid, key, null)); | |||
} | |||
@Test | |||
@@ -82,13 +83,15 @@ public class CeTaskComponentTest { | |||
String somethingElse = randomAlphabetic(5); | |||
CeTask.Component underTest = new CeTask.Component(uuid, key, name); | |||
assertThat(underTest.hashCode()).isEqualTo(underTest.hashCode()); | |||
assertThat(underTest.hashCode()).isEqualTo(new CeTask.Component(uuid, key, name).hashCode()); | |||
assertThat(underTest.hashCode()).isNotEqualTo(new Object().hashCode()); | |||
assertThat(underTest.hashCode()).isNotEqualTo(new CeTask.Component(somethingElse, key, name).hashCode()); | |||
assertThat(underTest.hashCode()).isNotEqualTo(new CeTask.Component(uuid, somethingElse, name).hashCode()); | |||
assertThat(underTest.hashCode()).isNotEqualTo(new CeTask.Component(uuid, key, somethingElse).hashCode()); | |||
assertThat(underTest.hashCode()).isNotEqualTo(new CeTask.Component(uuid, key, null).hashCode()); | |||
assertThat(underTest) | |||
.hasSameHashCodeAs(underTest) | |||
.hasSameHashCodeAs(new CeTask.Component(uuid, key, name)); | |||
assertThat(underTest.hashCode()) | |||
.isNotEqualTo(new Object().hashCode()) | |||
.isNotEqualTo(new CeTask.Component(somethingElse, key, name).hashCode()) | |||
.isNotEqualTo(new CeTask.Component(uuid, somethingElse, name).hashCode()) | |||
.isNotEqualTo(new CeTask.Component(uuid, key, somethingElse).hashCode()) | |||
.isNotEqualTo(new CeTask.Component(uuid, key, null).hashCode()); | |||
} | |||
@DataProvider |
@@ -121,8 +121,9 @@ public class CeTaskTest { | |||
assertThat(task1.equals(task1)).isTrue(); | |||
assertThat(task1.equals(task1bis)).isTrue(); | |||
assertThat(task1.equals(task2)).isFalse(); | |||
assertThat(task1.hashCode()).isEqualTo(task1.hashCode()); | |||
assertThat(task1.hashCode()).isEqualTo(task1bis.hashCode()); | |||
assertThat(task1) | |||
.hasSameHashCodeAs(task1) | |||
.hasSameHashCodeAs(task1bis); | |||
} | |||
@Test | |||
@@ -148,12 +149,13 @@ public class CeTaskTest { | |||
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()); | |||
assertThat(user1) | |||
.isEqualTo(user1) | |||
.isEqualTo(user1bis) | |||
.isNotEqualTo(user2) | |||
.hasSameHashCodeAs(user1) | |||
.hasSameHashCodeAs(user1bis) | |||
.hasSameHashCodeAs(user1_diff_login); | |||
} | |||
} |
@@ -72,7 +72,7 @@ public class TaskContainerImplTest { | |||
assertThat(defaultStartable.startCalls).isZero(); | |||
assertThat(defaultStartable.stopCalls).isZero(); | |||
assertThat(eagerStartable.startCalls).isEqualTo(1); | |||
assertThat(eagerStartable.startCalls).isOne(); | |||
assertThat(eagerStartable.stopCalls).isZero(); | |||
} | |||
@@ -90,8 +90,8 @@ public class TaskContainerImplTest { | |||
assertThat(defaultStartable.startCalls).isZero(); | |||
assertThat(defaultStartable.stopCalls).isZero(); | |||
assertThat(eagerStartable.startCalls).isEqualTo(1); | |||
assertThat(eagerStartable.stopCalls).isEqualTo(1); | |||
assertThat(eagerStartable.startCalls).isOne(); | |||
assertThat(eagerStartable.stopCalls).isOne(); | |||
} | |||
public static class DefaultStartable implements Startable { |
@@ -60,7 +60,7 @@ public class CeTaskMessagesMessageTest { | |||
.isEqualTo(new Message(text, timestamp)) | |||
.isNotEqualTo(new Message(text + "ç", timestamp)) | |||
.isNotEqualTo(new Message(text, timestamp + 10_999L)) | |||
.isNotEqualTo(null) | |||
.isNotNull() | |||
.isNotEqualTo(new Object()); | |||
} | |||
@@ -138,7 +138,7 @@ public class CeCleaningSchedulerImplTest { | |||
mockedInternalCeQueue, mockCeDistributedInformation(jobLock)); | |||
underTest.startScheduling(); | |||
assertThat(executorService.schedulerCounter).isEqualTo(1); | |||
assertThat(executorService.schedulerCounter).isOne(); | |||
} | |||
private CeConfiguration mockCeConfiguration(long cleanCeTasksInitialDelay, long cleanCeTasksDelay) { |
@@ -36,12 +36,12 @@ public class CeConfigurationImplTest { | |||
@Test | |||
public void getWorkerCount_returns_1_when_there_is_no_WorkerCountProvider() { | |||
assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getWorkerCount()).isEqualTo(1); | |||
assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getWorkerCount()).isOne(); | |||
} | |||
@Test | |||
public void getWorkerMaxCount_returns_1_when_there_is_no_WorkerCountProvider() { | |||
assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getWorkerMaxCount()).isEqualTo(1); | |||
assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getWorkerMaxCount()).isOne(); | |||
} | |||
@Test | |||
@@ -95,10 +95,10 @@ public class CeConfigurationImplTest { | |||
@Test | |||
public void getCleanCeTasksInitialDelay_returns_0() { | |||
assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getCleanTasksInitialDelay()) | |||
.isEqualTo(0L); | |||
.isZero(); | |||
workerCountProvider.set(1); | |||
assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION, workerCountProvider).getCleanTasksInitialDelay()) | |||
.isEqualTo(0L); | |||
.isZero(); | |||
} | |||
@Test |
@@ -58,7 +58,7 @@ public class CEQueueStatusImplConcurrentTest { | |||
executorService.awaitTermination(1, TimeUnit.SECONDS); | |||
assertThat(underTest.getInProgressCount()).isEqualTo(1); | |||
assertThat(underTest.getInProgressCount()).isOne(); | |||
assertThat(underTest.getErrorCount()).isEqualTo(17); | |||
assertThat(underTest.getSuccessCount()).isEqualTo(80); | |||
assertThat(underTest.getProcessingTime()).isEqualTo(177); |
@@ -58,7 +58,7 @@ public abstract class CommonCEQueueStatusImplTest { | |||
public void addInProgress_increases_InProgress() { | |||
getUnderTest().addInProgress(); | |||
assertThat(getUnderTest().getInProgressCount()).isEqualTo(1); | |||
assertThat(getUnderTest().getInProgressCount()).isOne(); | |||
assertThat(getUnderTest().getErrorCount()).isZero(); | |||
assertThat(getUnderTest().getSuccessCount()).isZero(); | |||
assertThat(getUnderTest().getProcessingTime()).isZero(); | |||
@@ -87,7 +87,7 @@ public abstract class CommonCEQueueStatusImplTest { | |||
getUnderTest().addError(SOME_PROCESSING_TIME); | |||
assertThat(getUnderTest().getInProgressCount()).isEqualTo(-1); | |||
assertThat(getUnderTest().getErrorCount()).isEqualTo(1); | |||
assertThat(getUnderTest().getErrorCount()).isOne(); | |||
assertThat(getUnderTest().getSuccessCount()).isZero(); | |||
assertThat(getUnderTest().getProcessingTime()).isEqualTo(SOME_PROCESSING_TIME); | |||
} | |||
@@ -117,7 +117,7 @@ public abstract class CommonCEQueueStatusImplTest { | |||
assertThat(getUnderTest().getInProgressCount()).isEqualTo(-1); | |||
assertThat(getUnderTest().getErrorCount()).isZero(); | |||
assertThat(getUnderTest().getSuccessCount()).isEqualTo(1); | |||
assertThat(getUnderTest().getSuccessCount()).isOne(); | |||
assertThat(getUnderTest().getProcessingTime()).isEqualTo(SOME_PROCESSING_TIME); | |||
} | |||
@@ -159,7 +159,7 @@ public class InternalCeQueueImplTest { | |||
// available in history | |||
Optional<CeActivityDto> history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid()); | |||
assertThat(history.isPresent()).isTrue(); | |||
assertThat(history).isPresent(); | |||
assertThat(history.get().getStatus()).isEqualTo(CeActivityDto.Status.SUCCESS); | |||
assertThat(history.get().getIsLast()).isTrue(); | |||
assertThat(history.get().getAnalysisUuid()).isNull(); | |||
@@ -187,7 +187,7 @@ public class InternalCeQueueImplTest { | |||
// available in history | |||
Optional<CeActivityDto> history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid()); | |||
assertThat(history.isPresent()).isTrue(); | |||
assertThat(history).isPresent(); | |||
assertThat(history.get().getAnalysisUuid()).isNull(); | |||
} | |||
@@ -200,7 +200,7 @@ public class InternalCeQueueImplTest { | |||
// available in history | |||
Optional<CeActivityDto> history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid()); | |||
assertThat(history.isPresent()).isTrue(); | |||
assertThat(history).isPresent(); | |||
assertThat(history.get().getAnalysisUuid()).isEqualTo("U1"); | |||
} | |||
@@ -330,7 +330,7 @@ public class InternalCeQueueImplTest { | |||
CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); | |||
Optional<CeTask> peek = underTest.peek(WORKER_UUID_1, true); | |||
assertThat(peek.isPresent()).isTrue(); | |||
assertThat(peek).isPresent(); | |||
assertThat(peek.get().getUuid()).isEqualTo(task.getUuid()); | |||
assertThat(peek.get().getType()).isEqualTo(CeTaskTypes.REPORT); | |||
assertThat(peek.get().getComponent()).contains(new CeTask.Component("PROJECT_1", null, null)); | |||
@@ -338,7 +338,7 @@ public class InternalCeQueueImplTest { | |||
// no more pending tasks | |||
peek = underTest.peek(WORKER_UUID_2, true); | |||
assertThat(peek.isPresent()).isFalse(); | |||
assertThat(peek).isEmpty(); | |||
} | |||
@Test | |||
@@ -348,7 +348,7 @@ public class InternalCeQueueImplTest { | |||
CeTask task = submit(CeTaskTypes.REPORT, branch); | |||
Optional<CeTask> peek = underTest.peek(WORKER_UUID_1, true); | |||
assertThat(peek.isPresent()).isTrue(); | |||
assertThat(peek).isPresent(); | |||
assertThat(peek.get().getUuid()).isEqualTo(task.getUuid()); | |||
assertThat(peek.get().getType()).isEqualTo(CeTaskTypes.REPORT); | |||
assertThat(peek.get().getComponent()).contains(new CeTask.Component(branch.uuid(), branch.getDbKey(), branch.name())); | |||
@@ -356,7 +356,7 @@ public class InternalCeQueueImplTest { | |||
// no more pending tasks | |||
peek = underTest.peek(WORKER_UUID_2, true); | |||
assertThat(peek.isPresent()).isFalse(); | |||
assertThat(peek).isEmpty(); | |||
} | |||
@Test | |||
@@ -391,7 +391,7 @@ public class InternalCeQueueImplTest { | |||
when(computeEngineStatus.getStatus()).thenReturn(STOPPING); | |||
Optional<CeTask> peek = underTest.peek(WORKER_UUID_1, true); | |||
assertThat(peek.isPresent()).isFalse(); | |||
assertThat(peek).isEmpty(); | |||
} | |||
@Test | |||
@@ -476,7 +476,7 @@ public class InternalCeQueueImplTest { | |||
underTest.cancel(db.getSession(), queueDto); | |||
Optional<CeActivityDto> activity = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid()); | |||
assertThat(activity.isPresent()).isTrue(); | |||
assertThat(activity).isPresent(); | |||
assertThat(activity.get().getStatus()).isEqualTo(CeActivityDto.Status.CANCELED); | |||
} | |||
@@ -506,7 +506,7 @@ public class InternalCeQueueImplTest { | |||
history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), pendingTask2.getUuid()); | |||
assertThat(history.get().getStatus()).isEqualTo(CeActivityDto.Status.CANCELED); | |||
history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), inProgressTask.getUuid()); | |||
assertThat(history.isPresent()).isFalse(); | |||
assertThat(history).isEmpty(); | |||
} | |||
@Test | |||
@@ -628,7 +628,7 @@ public class InternalCeQueueImplTest { | |||
private void verifyCeQueueDtoForTaskSubmit(CeTaskSubmit taskSubmit) { | |||
Optional<CeQueueDto> queueDto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), taskSubmit.getUuid()); | |||
assertThat(queueDto.isPresent()).isTrue(); | |||
assertThat(queueDto).isPresent(); | |||
CeQueueDto dto = queueDto.get(); | |||
assertThat(dto.getTaskType()).isEqualTo(taskSubmit.getType()); | |||
Optional<CeTaskSubmit.Component> component = taskSubmit.getComponent(); |