output
stringlengths 7
516k
| instruction
stringclasses 1
value | input
stringlengths 6
884k
|
|---|---|---|
```package fr.inria.spirals.repairnator.process.step;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.utils4tests.ProjectInspectorMocker;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.lib.Ref;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
/**
* Created by urli on 21/02/2017.
*/
public class TestCloneRepositoryStep {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Test
@Ignore
//FIXME: We can't rely on repairnator/failing project to get builds
public void testCloneMasterBuild() throws IOException {
long buildId = 220946365; // repairnator/failingProject erroring-branch
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_clone").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, toBeInspected);
CloneRepository cloneStep = new CloneRepository(inspector);
cloneStep.execute();
assertThat(cloneStep.isShouldStop(), is(false));
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertThat(stepStatusList.size(), is(1));
StepStatus cloneStatus = stepStatusList.get(0);
assertThat(cloneStatus.getStep(), is(cloneStep));
assertThat(cloneStatus.isSuccess(), is(true));
Git gitDir = Git.open(new File(tmpDir, "repo"));
Ref ref = gitDir.getRepository().exactRef("HEAD");
assertThat(ref.isSymbolic(), is(true));
ref = ref.getTarget();
assertThat(ref.getObjectId().getName(), not(build.getCommit().getSha())); // no check out yet
}
@Test
@Ignore
//FIXME: We can't rely on repairnator/failing project to get builds
public void testCloneBuildWithSubmodule() throws IOException {
long buildId = 220958889; // repairnator/failingProject test-with-submodule
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_clone").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, toBeInspected);
AbstractStep cloneStep = new CloneRepository(inspector).addNextStep(new CheckoutBuggyBuild(inspector, true));
cloneStep.execute();
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertThat(stepStatusList.size(), is(2));
StepStatus cloneStatus = stepStatusList.get(0);
assertThat(cloneStatus.getStep(), is(cloneStep));
assertThat(cloneStatus.isSuccess(), is(true));
File readmeInSubmodule = new File(tmpDir, "repo/test-repairnator-bears/README.md");
assertThat("Submodule are not supported", readmeInSubmodule.exists(), is(true));
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.process.inspectors.GitRepositoryProjectInspector;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.states.PipelineState;
import org.apache.commons.io.FileUtils;
import org.apache.http.client.UserTokenHandler;
import org.eclipse.jgit.api.CloneCommand;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
* Created by urli on 03/01/2017.
*/
public class CloneRepository extends AbstractStep {
protected Build build;
public CloneRepository(ProjectInspector inspector) {
super(inspector, true);
}
@Override
protected StepStatus businessExecute() {
GitRepositoryProjectInspector githubInspector;
try {
githubInspector = (GitRepositoryProjectInspector) getInspector();
} catch (Exception ex) {
this.addStepError("Problem with calling the inspector");
return StepStatus.buildError(this, PipelineState.NOTCLONABLE);
}
String branch = null;
if (githubInspector.getGitRepositoryBranch() != null) {
branch = "refs/heads/" + githubInspector.getGitRepositoryBranch();
}
String repoUrl = githubInspector.getGitRepositoryUrl() + ".git";
String repoLocalPath = githubInspector.getRepoLocalPath();
try {
this.getLogger().info("Cloning repository " + repoUrl + " in the following directory: " + repoLocalPath);
FileUtils.deleteDirectory(new File(repoLocalPath));
CloneCommand cloneRepositoryCommand = Git.cloneRepository()
.setCloneSubmodules(true)
.setURI(repoUrl)
.setDirectory(new File(repoLocalPath))
;
String auth=System.getenv("GOAUTH");
if(auth!=null){
cloneRepositoryCommand.setCredentialsProvider(new UsernamePasswordCredentialsProvider(
System.getenv("GOAUTH"),""));
}
cloneRepositoryCommand.call();
return StepStatus.buildSuccess(this);
} catch (Exception e) {
this.addStepError("Repository " + repoUrl + " cannot be cloned.", e);
return StepStatus.buildError(this, PipelineState.NOTCLONABLE);
}
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.paths;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutType;
import fr.inria.spirals.repairnator.process.utils4tests.ProjectInspectorMocker;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
public class TestComputeModules {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig.getInstance().setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Ignore("Test on Travis, not valid project")
@Test
public void testComputeModulesWithSingleModuleProject() throws IOException {
long buggyBuildCandidateId = 224246334; // repairnator/failingProject -> master
Build buggyBuildCandidate = this.checkBuildAndReturn(buggyBuildCandidateId, false);
BuildToBeInspected buildToBeInspected = new BuildToBeInspected(buggyBuildCandidate, null, ScannedBuildStatus.ONLY_FAIL, "test");
tmpDir = Files.createTempDirectory("test_compute_modules_with_single_module_project").toFile();
File repoDir = new File(tmpDir, "repo");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
jobStatus.setFailingModulePath(repoDir.getAbsolutePath());
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, buildToBeInspected, CheckoutType.CHECKOUT_BUGGY_BUILD);
CloneRepository cloneStep = new CloneRepository(inspector);
ComputeModules computeModules = new ComputeModules(inspector, true);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true)).addNextStep(computeModules);
cloneStep.execute();
assertThat(computeModules.isShouldStop(), is(false));
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertThat(stepStatusList.size(), is(3));
StepStatus classpathStatus = stepStatusList.get(2);
assertThat(classpathStatus.getStep(), is(computeModules));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
assertThat(jobStatus.getProperties().getProjectMetrics().getNumberModules(), is(1));
}
@Ignore("Test on Travis, not valid project")
@Test
public void testComputeModulesWithMultiModuleProject() throws IOException {
long buggyBuildCandidateId = 224264992; // repairnator/failingProject -> multi-module
Build buggyBuildCandidate = this.checkBuildAndReturn(buggyBuildCandidateId, false);
BuildToBeInspected buildToBeInspected = new BuildToBeInspected(buggyBuildCandidate, null, ScannedBuildStatus.ONLY_FAIL, "test");
tmpDir = Files.createTempDirectory("test_compute_modules_with_multi_module_project").toFile();
File repoDir = new File(tmpDir, "repo");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
jobStatus.setFailingModulePath(repoDir.getAbsolutePath());
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, buildToBeInspected, CheckoutType.CHECKOUT_BUGGY_BUILD);
CloneRepository cloneStep = new CloneRepository(inspector);
ComputeModules computeModules = new ComputeModules(inspector, true);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true)).addNextStep(computeModules);
cloneStep.execute();
assertThat(computeModules.isShouldStop(), is(false));
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertThat(stepStatusList.size(), is(3));
StepStatus classpathStatus = stepStatusList.get(2);
assertThat(classpathStatus.getStep(), is(computeModules));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
assertThat(jobStatus.getProperties().getProjectMetrics().getNumberModules(), is(6));
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.paths;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.maven.MavenHelper;
import fr.inria.spirals.repairnator.process.step.AbstractStep;
import fr.inria.spirals.repairnator.states.PipelineState;
import org.apache.maven.model.Model;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ComputeModules extends AbstractStep {
public ComputeModules(ProjectInspector inspector, boolean blockingStep) {
super(inspector, blockingStep);
}
private File[] findModules(String pomPath, boolean rootCall) {
List<File> modules = new ArrayList<>();
File pomFile = new File(pomPath);
Model model = MavenHelper.readPomXml(pomFile, this.getInspector().getM2LocalPath());
if (model == null) {
this.addStepError("Error while building model: no model has been retrieved.");
return null;
}
if (model.getModules() == null) {
this.addStepError("Error while obtaining modules from pom.xml: module section has not been found.");
return null;
}
for (String moduleName : model.getModules()) {
File module = new File(pomFile.getParent() + File.separator + moduleName);
modules.add(module);
File[] moreModules = this.findModules(module.getPath() + File.separator + Utils.POM_FILE, false);
if (moreModules != null && moreModules.length > 0) {
modules.addAll(Arrays.asList(moreModules));
}
}
if (rootCall && modules.size() == 0) {
modules.add(pomFile.getParentFile());
}
return modules.toArray(new File[modules.size()]);
}
@Override
protected StepStatus businessExecute() {
this.getLogger().debug("Computing project modules...");
String mainPomPath = this.getPom();
File[] modules = this.findModules(mainPomPath, true);
if (modules == null || modules.length == 0) {
this.getLogger().info("No module was computed.");
return StepStatus.buildError(this, PipelineState.MODULESNOTCOMPUTED);
}
this.getInspector().getJobStatus().setModules(modules);
this.getInspector().getJobStatus().getProperties().getProjectMetrics().setNumberModules(modules.length);
return StepStatus.buildSuccess(this);
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.push;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.utils4tests.ProjectInspectorMocker;
import fr.inria.spirals.repairnator.states.PushState;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.revwalk.RevCommit;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Date;
import java.util.Iterator;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;
/**
* Created by urli on 27/04/2017.
*/
public class TestCommitPatch {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setGithubUserEmail("noreply@github.com");
config.setGithubUserName("repairnator");
config.setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Ignore("This test is ignore because requires a valid JTravis repository")
@Test
public void testCommitRepairInfo() throws IOException, GitAPIException {
long buildId = 220946365; // repairnator/failingProject build
RepairnatorConfig repairnatorConfig = RepairnatorConfig.getInstance();
repairnatorConfig.setClean(false);
repairnatorConfig.setPush(true);
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_pushPatch").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
jobStatus.getProperties().getBuilds().setBuggyBuild(new fr.inria.spirals.repairnator.process.inspectors.properties.builds.Build(buildId, "", new Date()));
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, toBeInspected);
CloneRepository cloneStep = new CloneRepository(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true)).addNextStep(new InitRepoToPush(inspector)).addNextStep(new CommitPatch(inspector, CommitType.COMMIT_REPAIR_INFO));
cloneStep.execute();
assertTrue(jobStatus.getPushStates().contains(PushState.REPAIR_INFO_COMMITTED));
Git gitDir = Git.open(new File(tmpDir, "repotopush"));
Iterable<RevCommit> logs = gitDir.log().call();
Iterator<RevCommit> iterator = logs.iterator();
assertTrue(iterator.hasNext());
RevCommit commit = iterator.next();
assertTrue(commit.getShortMessage().contains("Automatic repair"));
commit = iterator.next();
assertTrue(commit.getShortMessage().contains("Bug commit"));
assertFalse(iterator.hasNext());
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.push;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.states.PushState;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import java.io.File;
import java.io.IOException;
/**
* Created by urli on 27/04/2017.
*/
public class CommitPatch extends CommitFiles {
public CommitPatch(ProjectInspector inspector, CommitType commitType) {
super(inspector);
this.commitType = commitType;
}
public CommitPatch(ProjectInspector inspector, String name, CommitType commitType) {
super(inspector, name);
this.commitType = commitType;
}
@Override
protected StepStatus businessExecute() {
if (this.getConfig().isPush()) {
if (this.commitType == CommitType.COMMIT_HUMAN_PATCH) {
this.getLogger().info("Commit human patch...");
} else {
this.getLogger().info("Commit info from repair tools...");
}
super.setCommitType(this.commitType);
try {
Git git = Git.open(new File(this.getInspector().getRepoToPushLocalPath()));
Ref oldHeadRef = git.getRepository().exactRef("HEAD");
RevWalk revWalk = new RevWalk(git.getRepository());
RevCommit headRev = revWalk.parseCommit(oldHeadRef.getObjectId());
revWalk.dispose();
StepStatus stepStatus = super.businessExecute();
if (stepStatus.isSuccess()) {
RevCommit commit = super.getCommit();
this.getInspector().getGitHelper().computePatchStats(this.getInspector().getJobStatus(), git, headRev, commit);
if (this.commitType == CommitType.COMMIT_HUMAN_PATCH) {
this.setPushState(PushState.PATCH_COMMITTED);
} else {
this.setPushState(PushState.REPAIR_INFO_COMMITTED);
}
} else {
if (this.commitType == CommitType.COMMIT_HUMAN_PATCH) {
this.setPushState(PushState.PATCH_NOT_COMMITTED);
} else {
this.setPushState(PushState.REPAIR_INFO_NOT_COMMITTED);
}
}
return stepStatus;
} catch (IOException e) {
this.addStepError("Error while opening the local git repository, maybe it has not been initialized.", e);
}
if (this.commitType == CommitType.COMMIT_HUMAN_PATCH) {
this.setPushState(PushState.PATCH_NOT_COMMITTED);
} else {
this.setPushState(PushState.REPAIR_INFO_NOT_COMMITTED);
}
return StepStatus.buildSkipped(this,"Error while committing.");
} else {
this.getLogger().info("Repairnator is configured NOT to push. Step bypassed.");
return StepStatus.buildSkipped(this);
}
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.paths;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutType;
import fr.inria.spirals.repairnator.process.utils4tests.ProjectInspectorMocker;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
/**
* Created by urli on 07/03/2017.
*/
public class TestComputeClasspath {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig.getInstance().setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Test
@Ignore
//FIXME: We can't rely on repairnator/failing project to get builds
public void testComputeClasspathWithSingleModuleProject() throws IOException {
long buildId = 220925392; // repairnator/failingProject -> master
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_computecp").toFile();
File repoDir = new File(tmpDir, "repo");
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
jobStatus.setFailingModulePath(repoDir.getAbsolutePath());
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, toBeInspected, CheckoutType.CHECKOUT_BUGGY_BUILD);
CloneRepository cloneStep = new CloneRepository(inspector);
ComputeClasspath computeClasspath = new ComputeClasspath(inspector, true);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true));
cloneStep.execute();
createTargetDir(new File(jobStatus.getFailingModulePath()));
computeClasspath.execute();
assertThat(computeClasspath.isShouldStop(), is(false));
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertThat(stepStatusList.size(), is(3));
StepStatus classpathStatus = stepStatusList.get(2);
assertThat(classpathStatus.getStep(), is(computeClasspath));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
List<URL> expectedClasspath = new ArrayList<URL>();
expectedClasspath.add(new URL("file:"+tmpDir.getAbsolutePath()+"/.m2/junit/junit/4.11/junit-4.11.jar"));
expectedClasspath.add(new URL("file:"+tmpDir.getAbsolutePath()+"/.m2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar"));
expectedClasspath.add(new URL("file:"+jobStatus.getFailingModulePath()+"/target/classes/"));
expectedClasspath.add(new URL("file:"+jobStatus.getFailingModulePath()+"/target/test-classes/"));
assertThat(jobStatus.getRepairClassPath(), is(expectedClasspath));
assertThat(jobStatus.getProperties().getProjectMetrics().getNumberLibrariesFailingModule(), is(2));
}
@Test
@Ignore
//FIXME: We can't rerun repairnator/test-repairnator-bears/builds/225920529
public void testComputeClasspathWithMultiModuleProject() throws IOException {
long buggyBuildCandidateId = 225920529; // https://travis-ci.com/github/repairnator/test-repairnator-bears/builds/225920529
Build buggyBuildCandidate = this.checkBuildAndReturn(buggyBuildCandidateId, false);
tmpDir = Files.createTempDirectory("test_computecp").toFile();
File repoDir = new File(tmpDir, "repo");
BuildToBeInspected toBeInspected = new BuildToBeInspected(buggyBuildCandidate, null, ScannedBuildStatus.ONLY_FAIL, "");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
jobStatus.setFailingModulePath(repoDir.getAbsolutePath() + File.separator + "test-repairnator-bears-core");
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, toBeInspected, CheckoutType.CHECKOUT_BUGGY_BUILD);
CloneRepository cloneStep = new CloneRepository(inspector);
ComputeClasspath computeClasspath = new ComputeClasspath(inspector, true);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true));
cloneStep.execute();
createTargetDir(new File(jobStatus.getFailingModulePath()));
computeClasspath.execute();
assertThat(computeClasspath.isShouldStop(), is(false));
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertThat(stepStatusList.size(), is(3));
StepStatus classpathStatus = stepStatusList.get(2);
assertThat(classpathStatus.getStep(), is(computeClasspath));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
List<URL> expectedClasspath = new ArrayList<URL>();
expectedClasspath.add(new URL("file:"+tmpDir.getAbsolutePath()+"/.m2/junit/junit/4.12/junit-4.12.jar"));
expectedClasspath.add(new URL("file:"+tmpDir.getAbsolutePath()+"/.m2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar"));
expectedClasspath.add(new URL("file:"+jobStatus.getFailingModulePath()+"/target/classes/"));
expectedClasspath.add(new URL("file:"+jobStatus.getFailingModulePath()+"/target/test-classes/"));
assertThat(jobStatus.getRepairClassPath(), is(expectedClasspath));
assertThat(jobStatus.getProperties().getProjectMetrics().getNumberLibrariesFailingModule(), is(2));
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
private void createTargetDir(File repoDir) {
File targetDir = new File(repoDir.getAbsolutePath(), "target");
targetDir.mkdir();
File classDir = new File(targetDir.getAbsolutePath(), "classes");
classDir.mkdir();
File testDir = new File(targetDir.getAbsolutePath(), "test-classes");
testDir.mkdir();
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.paths;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.AbstractStep;
import fr.inria.spirals.repairnator.states.PipelineState;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.maven.MavenHelper;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
/**
* Created by urli on 08/02/2017.
*/
public class ComputeClasspath extends AbstractStep {
private static final String goal = "dependency:build-classpath";
private static final String CLASSPATH_FILENAME = "classpath.info";
private static final String DEFAULT_CLASSES_DIR = "/target/classes";
private static final String DEFAULT_TEST_CLASSES_DIR = "/target/test-classes";
private List<URL> classPath;
public ComputeClasspath(ProjectInspector inspector, boolean blockingStep) {
super(inspector, blockingStep);
this.classPath = new ArrayList<>();
}
private void addFileToClassPath(File file) {
if (file.exists()) {
try {
this.classPath.add(file.toURI().toURL());
} catch (MalformedURLException e) {
this.addStepError("Error while adding the following file in the classpath: " +
file.getAbsolutePath() + ".", e);
}
} else {
this.addStepError("The file does not exist: " + file.getAbsolutePath() + ".");
}
}
private void addDefaultDirsToClassPath(String modulePath) {
File defaultClassDir = new File(modulePath + File.separator + DEFAULT_CLASSES_DIR + File.separator);
this.addFileToClassPath(defaultClassDir);
File defaultTestClassDir = new File(
modulePath + File.separator + DEFAULT_TEST_CLASSES_DIR + File.separator);
this.addFileToClassPath(defaultTestClassDir);
}
private int runMavenGoal(String pomPath, Properties properties) {
MavenHelper helper = new MavenHelper(pomPath, goal, properties, this.getClass().getSimpleName(),
this.getInspector(), true);
int result = MavenHelper.MAVEN_ERROR;
try {
result = helper.run();
} catch (InterruptedException e) {
this.addStepError("Error while executing maven goal.", e);
}
return result;
}
private void addJarFilesToClassPath(String classpathFilePath) {
try {
BufferedReader reader = new BufferedReader(new FileReader(new File(classpathFilePath)));
String classpathLine = reader.readLine();
if (classpathLine != null && !classpathLine.isEmpty()) {
String[] allJars = classpathLine.split(":");
for (String jar : allJars) {
File jarFile = new File(jar);
this.addFileToClassPath(jarFile);
}
this.getInspector().getJobStatus().addFileToPush(CLASSPATH_FILENAME);
} else {
this.addStepError("The classpath file is empty.");
}
} catch (IOException e) {
this.addStepError("Problem while getting classpath file.", e);
}
}
private void checkJUnitInClasspath() {
boolean containJunit = false;
for (URL url : this.classPath) {
if (url.toString().contains("junit")) {
containJunit = true;
}
}
if (!containJunit) {
this.addStepError("The classpath seems not to contain JUnit, maybe this project does not use JUnit for testing.");
}
}
@Override
protected StepStatus businessExecute() {
this.getLogger().debug("Computing classpath from incriminated module...");
String incriminatedModule = this.getInspector().getJobStatus().getFailingModulePath();
Properties properties = new Properties();
properties.setProperty("mdep.outputFile", CLASSPATH_FILENAME);
String pomModule = incriminatedModule + File.separator + Utils.POM_FILE;
String classpathFilePath = incriminatedModule + File.separator + CLASSPATH_FILENAME;
if (this.runMavenGoal(pomModule, properties) != MavenHelper.MAVEN_SUCCESS) {
this.addStepError("Error while computing classpath maven.");
return StepStatus.buildError(this, PipelineState.CLASSPATHERROR);
}
// Only jars will be added in the classpath here, which is the number of libraries of the failing module
this.addJarFilesToClassPath(classpathFilePath);
this.getInspector().getJobStatus().getProperties().getProjectMetrics().setNumberLibrariesFailingModule(this.classPath.size());
this.checkJUnitInClasspath();
// Default "/target/classes" and "/target/test-classes" dirs are then added here
this.addDefaultDirsToClassPath(incriminatedModule);
this.getInspector().getJobStatus().setRepairClassPath(this.classPath);
this.getLogger().debug("Computed classpath " + this.classPath);
return StepStatus.buildSuccess(this);
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.repair;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.inspectors.RepairPatch;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.TestProject;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.gatherinfo.BuildShouldFail;
import fr.inria.spirals.repairnator.process.step.gatherinfo.GatherTestInformation;
import fr.inria.spirals.repairnator.process.step.paths.ComputeClasspath;
import fr.inria.spirals.repairnator.process.step.paths.ComputeSourceDir;
import fr.inria.spirals.repairnator.process.step.paths.ComputeTestDir;
import fr.inria.spirals.repairnator.process.step.repair.astor.AstorJKaliRepair;
import fr.inria.spirals.repairnator.process.step.repair.astor.AstorJMutRepair;
import fr.inria.spirals.repairnator.serializer.AbstractDataSerializer;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.*;
@Ignore
public class TestAstorRepair {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Test
public void testAstorJkali() throws IOException {
long buildId = 220950805; // repairnator/failingProject astor-jkali-failure restarted on Dec 2022
Build build = this.checkBuildAndReturn(buildId, false);
AstorJKaliRepair astorJKaliRepair = new AstorJKaliRepair();
RepairnatorConfig.getInstance().setRepairTools(Collections.singleton(astorJKaliRepair.getRepairToolName()));
tmpDir = Files.createTempDirectory("test_astorjkali").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
astorJKaliRepair.setProjectInspector(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new TestProject(inspector))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(new ComputeClasspath(inspector, true))
.addNextStep(new ComputeSourceDir(inspector, true, false))
.addNextStep(new ComputeTestDir(inspector, true))
.addNextStep(astorJKaliRepair);
cloneStep.execute();
assertThat(astorJKaliRepair.isShouldStop(), is(false));
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertThat(stepStatusList.size(), is(8));
StepStatus assertFixerStatus = stepStatusList.get(7);
assertThat(assertFixerStatus.getStep(), is(astorJKaliRepair));
for (StepStatus stepStatus : stepStatusList) {
assertThat("Failing step :" + stepStatus, stepStatus.isSuccess(), is(true));
}
String finalStatus = AbstractDataSerializer.getPrettyPrintState(inspector);
assertThat(finalStatus, is("PATCHED"));
List<RepairPatch> allPatches = inspector.getJobStatus().getAllPatches();
assertThat(allPatches.isEmpty(), is(false));
assertThat(inspector.getJobStatus().getToolDiagnostic().get(astorJKaliRepair.getRepairToolName()), notNullValue());
for (RepairPatch repairPatch : allPatches) {
assertTrue(new File(repairPatch.getFilePath()).exists());
}
}
@Test
public void testAstorJMut() throws IOException {
long buildId = 220950959; // repairnator/failingProject math-85 restarted on 17/01/23
Build build = this.checkBuildAndReturn(buildId, false);
AstorJMutRepair astorJMutRepair = new AstorJMutRepair();
RepairnatorConfig.getInstance().setRepairTools(Collections.singleton(astorJMutRepair.getRepairToolName()));
tmpDir = Files.createTempDirectory("test_astorjkali").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
astorJMutRepair.setProjectInspector(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new TestProject(inspector))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(new ComputeClasspath(inspector, true))
.addNextStep(new ComputeSourceDir(inspector, true, false))
.addNextStep(new ComputeTestDir(inspector, true))
.addNextStep(astorJMutRepair);
cloneStep.execute();
assertThat(astorJMutRepair.isShouldStop(), is(false));
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertEquals(8, stepStatusList.size());
StepStatus assertFixerStatus = stepStatusList.get(7);
assertThat(assertFixerStatus.getStep(), is(astorJMutRepair));
for (StepStatus stepStatus : stepStatusList) {
assertThat("Failing step :" + stepStatus, stepStatus.isSuccess(), is(true));
}
String finalStatus = AbstractDataSerializer.getPrettyPrintState(inspector);
assertThat(finalStatus, is("PATCHED"));
List<RepairPatch> allPatches = inspector.getJobStatus().getAllPatches();
assertThat(allPatches.isEmpty(), is(false));
for (RepairPatch repairPatch : allPatches) {
assertTrue(new File(repairPatch.getFilePath()).exists());
}
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.repair.astor;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;
import fr.inria.astor.core.entities.ProgramVariant;
import fr.inria.astor.core.setup.ConfigurationProperties;
import fr.inria.main.AstorOutputStatus;
import fr.inria.main.evolution.AstorMain;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.RepairPatch;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.repair.AbstractRepairStep;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import spoon.SpoonException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
/**
* Created by urli on 17/08/2017.
*/
public abstract class AstorRepair extends AbstractRepairStep {
private static final int MAX_TIME_EXECUTION = 100; // in minutes
public AstorRepair() {}
public abstract String getAstorMode();
@Override
protected StepStatus businessExecute() {
this.getLogger().info("Start to repair using " + this.getRepairToolName());
JobStatus jobStatus = this.getInspector().getJobStatus();
List<RepairPatch> astorPatches = new ArrayList<>();
List<URL> classPath = this.getInspector().getJobStatus().getRepairClassPath();
File[] sources = this.getInspector().getJobStatus().getRepairSourceDir();
if (classPath != null && sources != null) {
List<String> dependencies = new ArrayList<>();
for (URL url : jobStatus.getRepairClassPath()) {
if (url.getFile().endsWith(".jar")) {
dependencies.add(url.getPath());
}
}
final List<String> astorArgs = new ArrayList<>();
astorArgs.add("-dependencies");
astorArgs.add(StringUtils.join(dependencies,":"));
astorArgs.add("-mode");
astorArgs.add(this.getAstorMode());
astorArgs.add("-location");
astorArgs.add(jobStatus.getFailingModulePath());
String relativeSourcePath = new File(jobStatus.getFailingModulePath()).toURI().relativize(jobStatus.getRepairSourceDir()[0].toURI()).getPath();
astorArgs.add("-srcjavafolder");
astorArgs.add(relativeSourcePath);
astorArgs.add("-stopfirst");
astorArgs.add("true");
astorArgs.add("-population");
astorArgs.add("1");
//astorArgs.add("-loglevel");
//astorArgs.add("DEBUG");
astorArgs.add("-parameters");
astorArgs.add("timezone:Europe/Paris:maxnumbersolutions:3:limitbysuspicious:false:maxmodificationpoints:1000:javacompliancelevel:8:logfilepath:"+this.getInspector().getRepoLocalPath()+"/repairnator.astor." + this.getAstorMode() + ".log");
astorArgs.add("-maxtime");
astorArgs.add(MAX_TIME_EXECUTION+"");
astorArgs.add("-seed");
astorArgs.add("1");
astorArgs.add("-faultlocalization");
astorArgs.add("CoCoSpoon");
String id = this.getRepairToolName() + "-" + getInspector().getProjectIdToBeInspected();
astorArgs.add("-id");
astorArgs.add(id);
final AstorMain astorMain = new AstorMain();
final String repairToolName = this.getRepairToolName();
final ExecutorService executor = Executors.newSingleThreadExecutor();
final Future<AstorOutputStatus> astorExecution = executor.submit(new Callable<AstorOutputStatus>() {
@Override
public AstorOutputStatus call() throws Exception {
AstorOutputStatus status = null;
try {
astorMain.execute(astorArgs.toArray(new String[0]));
if (astorMain.getEngine() != null) {
status = astorMain.getEngine().getOutputStatus();
} else {
status = AstorOutputStatus.ERROR;
}
} catch (SpoonException e) {
status = AstorOutputStatus.ERROR;
addStepError("Got SpoonException while running " + repairToolName, e);
} catch (RuntimeException e) {
addStepError("Got runtime exception while running " + repairToolName, e);
status = AstorOutputStatus.ERROR;
}
return status;
}
});
AstorOutputStatus status = null;
try {
executor.shutdown();
status = astorExecution.get(MAX_TIME_EXECUTION, TimeUnit.MINUTES);
if (astorMain.getEngine() != null) {
List<ProgramVariant> solutions = astorMain.getEngine().getSolutions();
if (solutions != null) {
for (ProgramVariant pv : solutions) {
if (pv.isSolution()) {
RepairPatch repairPatch = new RepairPatch(this.getRepairToolName(), "" , pv.getPatchDiff().getFormattedDiff());
astorPatches.add(repairPatch);
}
}
}
}
} catch (Exception e) {
status = AstorOutputStatus.ERROR;
this.addStepError("Error while executing " + repairToolName + " with args: "+ StringUtils.join(astorArgs,","), e);
}
jobStatus.addFileToPush("repairnator.astor." + this.getAstorMode() + ".log");
String jsonpath;
try {
jsonpath = astorMain.getEngine().getProjectFacade().getProperties().getWorkingDirRoot() + File.separator + ConfigurationProperties.getProperty("jsonoutputname") + ".json";
} catch (NullPointerException e) {
jsonpath = null;
}
if (jsonpath != null) {
File jsonResultFile = new File(jsonpath);
if (jsonResultFile.exists()) {
try {
FileUtils.copyFile(jsonResultFile, new File(this.getInspector().getRepoLocalPath()+"/repairnator.astor." + this.getAstorMode() + ".results.json"));
} catch (IOException e) {
this.addStepError("Error while moving " + this.getRepairToolName() + " JSON results", e);
}
JsonParser jsonParser = new JsonParser();
try {
JsonElement root = jsonParser.parse(new FileReader(jsonResultFile));
root.getAsJsonObject().add("status", new JsonPrimitive(status.name()));
this.recordToolDiagnostic(root);
} catch (FileNotFoundException e) {
this.addStepError("Error while reading " + this.getRepairToolName() + " JSON results", e);
}
jobStatus.addFileToPush("repairnator.astor." + this.getAstorMode() + ".results.json");
}
}
astorPatches = this.performPatchAnalysis(astorPatches);
if (astorPatches.isEmpty()) {
return StepStatus.buildPatchNotFound(this);
} else {
this.getInspector().getJobStatus().setHasBeenPatched(true);
this.recordPatches(astorPatches,MAX_PATCH_PER_TOOL);
return StepStatus.buildSuccess(this);
}
}
return StepStatus.buildSkipped(this,"Classpath or sources not computed.");
}
}
```
|
```package fr.inria.spirals.repairnator.scanner;
import fr.inria.spirals.repairnator.realtime.GithubPullRequestScanner;
import fr.inria.spirals.repairnator.realtime.githubapi.commits.models.SelectedPullRequest;
import org.junit.Test;
import java.time.Instant;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static org.junit.Assert.*;
public class GithubPullRequestScannerTest {
// Test to detect failing open pull requests
@Test
public void testFetchFailingPullRequests() throws Exception {
Set<String> repositorySet = new HashSet<>();
String repository = "repairnator/failingProject";
repositorySet.add(repository);
GithubPullRequestScanner scanner =
new GithubPullRequestScanner(GithubPullRequestScanner.FetchMode.FAILED, repositorySet);
// It searches for all the failing open pull requests opened after the current instant
List<SelectedPullRequest> selectedPullRequestList =
scanner.fetch(Instant.now().toEpochMilli(), System.currentTimeMillis(), repository, true);
assertEquals(0, selectedPullRequestList.size());
// It searches for all the failing open pull requests opened after Jan 01 01:00:00 CET 1970
selectedPullRequestList = scanner.fetch(new Date(0).getTime(), System.currentTimeMillis(), repository, true);
assertTrue(selectedPullRequestList.size() > 0);
// https://github.com/repairnator/failingProject/pull/7 (failing pull request)
assertTrue(selectedPullRequestList.stream().anyMatch(pr -> pr.getNumber() == 7));
// https://github.com/repairnator/failingProject/pull/3 (not failing pull request)
assertFalse(selectedPullRequestList.stream().anyMatch(pr -> pr.getNumber() == 3));
}
// Test to detect successful and failing open pull requests
@Test
public void testFetchAllOpenPullRequests() throws Exception {
Set<String> repositorySet = new HashSet<>();
String repository = "repairnator/failingProject";
repositorySet.add(repository);
GithubPullRequestScanner scanner =
new GithubPullRequestScanner(GithubPullRequestScanner.FetchMode.ALL, repositorySet);
// It searches for all open pull requests opened after Jan 01 01:00:00 CET 1970
List<SelectedPullRequest> selectedPullRequestList = selectedPullRequestList = scanner.fetch(new Date(0).getTime(), System.currentTimeMillis(), repository, true);
assertTrue(selectedPullRequestList.size() > 0);
// https://github.com/repairnator/failingProject/pull/3 (not failing pull request)
assertTrue(selectedPullRequestList.stream().anyMatch(pr -> pr.getNumber() == 3));
// https://github.com/repairnator/failingProject/pull/7 (failing pull request)
assertTrue(selectedPullRequestList.stream().anyMatch(pr -> pr.getNumber() == 7));
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.realtime;
import fr.inria.spirals.repairnator.realtime.githubapi.commits.models.SelectedPullRequest;
import fr.inria.spirals.repairnator.realtime.githubapi.pullrequests.GithubAPIPullRequestAdapter;
import java.util.List;
import java.util.Set;
public class GithubPullRequestScanner {
FetchMode fetchMode;
Set<String> repos;
public GithubPullRequestScanner(GithubPullRequestScanner.FetchMode fetchMode, Set<String> repos) {
this.fetchMode = fetchMode;
this.repos = repos;
}
public List<SelectedPullRequest> fetch(long startDateForScanning, long startTime, String repo, boolean isFirstScan) throws Exception {
return GithubAPIPullRequestAdapter.getInstance().getSelectedPullRequests(startDateForScanning, startTime, isFirstScan, fetchMode, repo);
}
public enum FetchMode {
FAILED, ALL, PASSING
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.repair;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.inspectors.RepairPatch;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.TestProject;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.gatherinfo.BuildShouldFail;
import fr.inria.spirals.repairnator.process.step.gatherinfo.GatherTestInformation;
import fr.inria.spirals.repairnator.process.step.paths.ComputeClasspath;
import fr.inria.spirals.repairnator.process.step.paths.ComputeSourceDir;
import fr.inria.spirals.repairnator.process.step.paths.ComputeTestDir;
import fr.inria.spirals.repairnator.serializer.AbstractDataSerializer;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
public class TestAssertFixerRepair {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Test
@Ignore
//TODO: Add a test with a failing build from GitHub Actions
public void testAssertFixerFixes() throws IOException {
long buildId = 220950016; // repairnator/failingProject build
Build build = this.checkBuildAndReturn(buildId, false);
RepairnatorConfig.getInstance().setRepairTools(Collections.singleton(AssertFixerRepair.TOOL_NAME));
tmpDir = Files.createTempDirectory("test_assertfixer").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
AssertFixerRepair assertFixerRepair = new AssertFixerRepair();
assertFixerRepair.setProjectInspector(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new TestProject(inspector))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(new ComputeClasspath(inspector, true))
.addNextStep(new ComputeSourceDir(inspector, true, false))
.addNextStep(new ComputeTestDir(inspector, true))
.addNextStep(assertFixerRepair);
cloneStep.execute();
assertThat(assertFixerRepair.isShouldStop(), is(false));
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertThat(stepStatusList.size(), is(8));
StepStatus assertFixerStatus = stepStatusList.get(7);
assertThat(assertFixerStatus.getStep(), is(assertFixerRepair));
for (StepStatus stepStatus : stepStatusList) {
assertThat("Failing step :" + stepStatus, stepStatus.isSuccess(), is(true));
}
String finalStatus = AbstractDataSerializer.getPrettyPrintState(inspector);
assertThat(finalStatus, is("PATCHED"));
List<RepairPatch> allPatches = inspector.getJobStatus().getAllPatches();
for (RepairPatch p :inspector.getJobStatus().getAllPatches()) {
// System.out.println(p.getDiff());
}
assertThat(allPatches.size(), is(8));
assertThat(inspector.getJobStatus().getToolDiagnostic().get(assertFixerRepair.getRepairToolName()), notNullValue());
for (RepairPatch repairPatch : allPatches) {
assertTrue(new File(repairPatch.getFilePath()).exists());
}
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.repair;
import com.google.common.io.Files;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import eu.stamp.project.assertfixer.AssertFixerResult;
import eu.stamp.project.assertfixer.Configuration;
import eu.stamp.project.assertfixer.Main;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.RepairPatch;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.testinformation.FailureLocation;
import java.io.File;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
public class AssertFixerRepair extends AbstractRepairStep {
protected static final String TOOL_NAME = "AssertFixer";
private static final int TOTAL_TIME = 30; // 30 minutes
public AssertFixerRepair() {
}
@Override
public String getRepairToolName() {
return TOOL_NAME;
}
@Override
protected StepStatus businessExecute() {
this.getLogger().info("Start AssertFixerRepair");
JobStatus jobStatus = this.getInspector().getJobStatus();
List<URL> classPath = jobStatus.getRepairClassPath();
File[] sources = jobStatus.getRepairSourceDir();
File[] tests = jobStatus.getTestDir();
if (tests == null || tests.length == 0) {
addStepError("No test directory found, this step won't be executed.");
return StepStatus.buildSkipped(this, "No test directory found, this step won't be executed.");
}
Configuration configuration = new Configuration();
configuration.setVerbose(true);
if (sources != null && sources.length > 0) {
List<String> sourceList = new ArrayList<>();
for (File source : sources) {
sourceList.add(source.getAbsolutePath());
}
configuration.setPathToSourceFolder(sourceList);
}
List<String> testList = new ArrayList<>();
for (File testFolder : tests) {
testList.add(testFolder.getAbsolutePath());
}
configuration.setPathToTestFolder(testList);
StringBuilder classpathBuilder = new StringBuilder();
for (String s: System.getProperty("java.class.path").split(File.pathSeparator)) {
if (s.contains("assert-fixer")) { // require to get access to "Logger" in the instrumented code
try {
classPath.add(new URI("file:" + new File(s).getAbsolutePath()).toURL());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
// FIXME: AssertFixer is not compliant with junit 4.4
for (int i = 0; i < classPath.size(); i++) {
classpathBuilder.append(classPath.get(i).getPath());
if (i < classPath.size() - 1) {
classpathBuilder.append(":");
}
}
configuration.setClasspath(classpathBuilder.toString());
Map<String, List<String>> multipleTestCases = new HashMap<>();
for (FailureLocation failureLocation : this.getInspector().getJobStatus().getFailureLocations()) {
List<String> failingMethods = new ArrayList<>(failureLocation.getErroringMethods());
failingMethods.addAll(failureLocation.getFailingMethods());
multipleTestCases.put(failureLocation.getClassName(), failingMethods);
}
configuration.setMultipleTestCases(multipleTestCases);
File outDir = Files.createTempDir();
configuration.setOutput(outDir.getAbsolutePath());
String asJson = new GsonBuilder().setPrettyPrinting().create().toJson(configuration);
this.getLogger().info("Launcher AssertFixer with the following configuration: "+asJson);
final ExecutorService executor = Executors.newSingleThreadExecutor();
final Future<List<AssertFixerResult>> assertFixerExecution = executor.submit(() -> {
try {
Main main = new Main(configuration);
return main.runWithResults();
} catch (Throwable throwable) {
addStepError("Got exception when running AssertFixer: ", throwable);
return new ArrayList<>();
}
});
List<AssertFixerResult> assertFixerResults = new ArrayList<>();
try {
executor.shutdown();
assertFixerResults.addAll(assertFixerExecution.get(TOTAL_TIME, TimeUnit.MINUTES));
} catch (Exception e) {
addStepError("Error while executing AssertFixer", e);
}
List<RepairPatch> listPatches = new ArrayList<>();
JsonArray toolDiagnostic = new JsonArray();
boolean success = false;
for (AssertFixerResult result : assertFixerResults) {
JsonObject diag = new JsonObject();
diag.addProperty("success", result.isSuccess());
diag.addProperty("className", result.getTestClass());
diag.addProperty("methodName", result.getTestMethod());
diag.addProperty("exceptionMessage",result.getExceptionMessage());
diag.addProperty("repairType", result.getRepairType().name());
toolDiagnostic.add(diag);
if (result.isSuccess()) {
success = true;
String path = result.getTestClass().replace(".","/") + ".java";
for (File dir : this.getInspector().getJobStatus().getTestDir()) {
String tmpPath = dir.getAbsolutePath() + "/" + path;
if (new File(tmpPath).exists()) {
path = tmpPath;
break;
}
}
RepairPatch patch = new RepairPatch(this.getRepairToolName(), path, result.getDiff());
listPatches.add(patch);
}
}
listPatches = this.performPatchAnalysis(listPatches);
if (listPatches.isEmpty()) {
return StepStatus.buildPatchNotFound(this);
}
this.recordPatches(listPatches,MAX_PATCH_PER_TOOL);
this.recordToolDiagnostic(toolDiagnostic);
outDir.delete();
if (success) {
jobStatus.setHasBeenPatched(true);
return StepStatus.buildSuccess(this);
} else {
return StepStatus.buildPatchNotFound(this);
}
}
}```
|
```package io.jenkins.plugins.main;
import hudson.model.FreeStyleBuild;
import hudson.model.FreeStyleProject;
import hudson.model.Label;
import org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition;
import org.jenkinsci.plugins.workflow.job.WorkflowJob;
import org.jenkinsci.plugins.workflow.job.WorkflowRun;
import org.junit.Rule;
import org.junit.Test;
import org.junit.Ignore;
import org.jvnet.hudson.test.JenkinsRule;
@Ignore("Only run manually, to avoid using up limitied bandwidth on Git")
public class RepairnatorPostBuildTest {
public @Rule JenkinsRule jenkins = new JenkinsRule();
final String gitUrl = "https://github.com/surli/failingProject";
final String gitOAuthToken = "";
final String gitBranch = "master";
@Test
public void testNPEFIX() throws Exception {
FreeStyleProject project = jenkins.createFreeStyleProject();
RepairnatorPostBuild postBuild = new RepairnatorPostBuild();
postBuild.setGitUrl(gitUrl);
postBuild.setGitOAuthToken(gitOAuthToken);
postBuild.setGitBranch(gitBranch);
postBuild.setUseNPEFix(true);
project.getPublishersList().add(postBuild);
FreeStyleBuild build = jenkins.buildAndAssertSuccess(project);
jenkins.assertLogContains("PIPELINE FINDING: PATCHED", build);
}
}```
|
Please help me generate a test for this class.
|
```package io.jenkins.plugins.main;
import hudson.Launcher;
import hudson.Extension;
import hudson.model.Action;
import hudson.EnvVars;
import hudson.tasks.*;
import hudson.util.FormValidation;
import hudson.model.AbstractBuild;
import hudson.model.BuildListener;
import hudson.model.AbstractProject;
import net.sf.json.JSONObject;
import org.kohsuke.stapler.DataBoundConstructor;
import org.kohsuke.stapler.StaplerRequest;
import org.kohsuke.stapler.QueryParameter;
import org.kohsuke.stapler.DataBoundSetter;
import org.jenkinsci.plugins.workflow.steps.StepContext;
import javax.servlet.ServletException;
import java.io.IOException;
import java.io.PrintStream;
import java.util.logging.*;
import java.io.IOException;
import java.lang.InterruptedException;
import java.util.Map;
import java.util.Arrays;
import java.io.File;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.lang.ProcessBuilder;
import java.lang.Process;
import java.io.FileNotFoundException;
import java.lang.InterruptedException;
import hudson.tasks.Maven;
import hudson.tools.ToolProperty;
import hudson.tasks.Maven.MavenInstallation;
import hudson.tasks.Maven.MavenInstaller;
import hudson.DescriptorExtensionList;
import hudson.tools.ToolProperty;
import hudson.tools.ToolPropertyDescriptor;
import hudson.model.Node;
import hudson.FilePath;
import org.apache.commons.io.FileUtils;
import hudson.slaves.EnvironmentVariablesNodeProperty;
import hudson.slaves.NodeProperty;
import hudson.slaves.NodePropertyDescriptor;
import hudson.util.DescribableList;
import hudson.Util;
import jenkins.model.Jenkins;
import java.util.List;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Date;
import java.nio.file.Files;
import java.nio.file.attribute.FileTime;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.TimeUnit;
import java.util.HashMap;
import java.util.Locale;
/* Post build class for post build action*/
public class RepairnatorPostBuild extends Recorder {
private String gitUrl;
private String gitOAuthToken;
private String gitBranch;
private String notifyTo;
private boolean useNPEFix;
private boolean useAstorJKali;
private boolean useAstorJMut;
private boolean useNPEFixSafe;
private boolean useNopolTestExclusionStrategy;
private boolean useSorald;
private final Config config = new Config();
private boolean sonarRulesGiven;
/* Rules */
private boolean rule1656;
private boolean rule1854;
private boolean rule1860;
private boolean rule1948;
private boolean rule2095;
private boolean rule2111;
private boolean rule2116;
private boolean rule2164;
private boolean rule2167;
private boolean rule2184;
private boolean rule2204;
private boolean rule2272;
private boolean rule3032;
private boolean rule3067;
private boolean rule3984;
private boolean rule4973;
private SonarRulesBlock sonarRulesBlock;
@DataBoundConstructor
public RepairnatorPostBuild(String gitUrl,String gitOAuthToken,String gitBranch,String notifyTo,SonarRulesBlock sonarRulesBlock) {
this.gitUrl = gitUrl;
this.gitOAuthToken = gitOAuthToken;
this.gitBranch = gitBranch;
this.notifyTo = notifyTo;
this.sonarRulesBlock = sonarRulesBlock;
if (sonarRulesBlock != null) {
sonarRulesBlock.rulesProvided = true;
}
}
public RepairnatorPostBuild() {
}
/* Repair Tools*/
@DataBoundSetter
public void setUseNPEFix(boolean useNPEFix) {
this.useNPEFix = useNPEFix;
}
@DataBoundSetter
public void setUseAstorJKali(boolean useAstorJKali) {
this.useAstorJKali = useAstorJKali;
}
@DataBoundSetter
public void setUseAstorJMut(boolean useAstorJMut) {
this.useAstorJMut = useAstorJMut;
}
@DataBoundSetter
public void setUseNPEFixSafe(boolean useNPEFixSafe) {
this.useNPEFixSafe = useNPEFixSafe;
}
@DataBoundSetter
public void setUseNopolTestExclusionStrategy(boolean useNopolTestExclusionStrategy) {
this.useNopolTestExclusionStrategy = useNopolTestExclusionStrategy;
}
@DataBoundSetter
public void setUseSorald(boolean useSorald) {
this.useSorald = useSorald;
}
public boolean getSonarRulesBlock() {
return this.sonarRulesBlock != null;
}
public boolean getRule1656() {
return SonarRulesBlock.rule1656;
}
public boolean getRule1854() {
return SonarRulesBlock.rule1854;
}
public boolean getRule1860() {
return SonarRulesBlock.rule1860;
}
public boolean getRule1948() {
return SonarRulesBlock.rule1948;
}
public boolean getRule2095() {
return SonarRulesBlock.rule2095;
}
public boolean getRule2111() {
return SonarRulesBlock.rule2111;
}
public boolean getRule2116() {
return SonarRulesBlock.rule2116;
}
public boolean getRule2164() {
return SonarRulesBlock.rule2164;
}
public boolean getRule2167() {
return SonarRulesBlock.rule2167;
}
public boolean getRule2184() {
return SonarRulesBlock.rule2184;
}
public boolean getRule2204() {
return SonarRulesBlock.rule2204;
}
public boolean getRule2272() {
return SonarRulesBlock.rule2272;
}
public boolean getRule3032() {
return SonarRulesBlock.rule3032;
}
public boolean getRule3067() {
return SonarRulesBlock.rule3067;
}
public boolean getRule3984() {
return SonarRulesBlock.rule3984;
}
public boolean getRule4973() {
return SonarRulesBlock.rule4973;
}
public void setGitUrl(String gitUrl) {
this.gitUrl = gitUrl;
}
public void setGitOAuthToken(String gitOAuthToken) {
this.gitOAuthToken = gitOAuthToken;
}
public void setGitBranch(String gitBranch) {
this.gitBranch = gitBranch;
}
public void setNotifyTo(String notifyTo) {
this.notifyTo = notifyTo;
}
public String getGitUrl() {
return gitUrl;
}
public String getGitOAuthToken() {
return this.gitOAuthToken;
}
public String getGitBranch() {
return this.gitBranch;
}
public String getNotifyTo() {
return this.notifyTo;
}
public boolean useTLS() {
return this.config.useTLSOrSSL();
}
public boolean getUseNPEFix() {
return useNPEFix;
}
public boolean getUseAstorJKali() {
return useAstorJKali;
}
public boolean getUseAstorJMut() {
return useAstorJMut;
}
public boolean getUseNPEFixSafe() {
return useNPEFixSafe;
}
public boolean getUseNopolTestExclusionStrategy() {
return useNopolTestExclusionStrategy;
}
public boolean getUseSorald() {
return useSorald;
}
public String[] getTools(){
String dummy = "";
if (this.useNPEFix) {
dummy += ",NPEFix";
}
if (this.useAstorJKali) {
dummy += ",AstorJKali";
}
if (this.useAstorJMut) {
dummy += ",AstorJMut";
}
if (this.useNPEFixSafe) {
dummy += ",NPEFixSafe";
}
if (this.useNopolTestExclusionStrategy) {
dummy += ",NopolTestExclusionStrategy";
}
if (this.useSorald) {
dummy += ",Sorald";
}
return dummy.substring(1,dummy.length()).split(",");
}
public Config getConfig() {
return this.config;
}
public void printProcessOutPut(Process process) throws IOException{
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(process.getInputStream()))) {
reader.lines().forEach(line -> System.out.println(line));
}
}
public void printAllEnv(AbstractBuild build,BuildListener listener) throws IOException,InterruptedException{
System.out.println("-----------Printing Env----------");
final EnvVars env = build.getEnvironment(listener);
for(String key : env.keySet()) {
System.out.println(key + ":" + env.get(key));
}
System.out.println("---------------------------------");
}
public void runRepairnator(EnvVars env) throws IOException,InterruptedException{
Config config = this.config;
System.out.println("jar location " + config.getJarLocation());
RepairnatorProcessBuilder repProcBuilder = new RepairnatorProcessBuilder()
.useJavaExec(config.getJavaExec())
.atJarLocation(config.getJarLocation())
.onGitUrl(config.getGitUrl())
.onGitBranch(config.getGitBranch())
.onGitOAuth(config.getGitOAuth())
.withSmtpUsername(config.getSmtpUsername())
.withSmtpPassword(config.getSmtpPassword())
.withSmtpServer(config.getSmtpServer())
.withSmtpPort(config.getSmtpPort())
.shouldNotifyTo(config.getNotifyTo())
.withRepairTools(config.getTools())
.withSonarRules(config.getSonarRules())
.useSmtpTls(config.useTLSOrSSL())
.asNoTravisRepair()
.alsoCreatePR()
.withMavenHome(config.getMavenHome())
.atWorkSpace(config.getWorkspaceDir().getAbsolutePath())
.withOutputDir(config.getWorkspaceDir().getAbsolutePath());
ProcessBuilder builder = repProcBuilder.build().directory(config.getWorkspaceDir());
builder.redirectErrorStream(true);
builder.inheritIO().redirectOutput(ProcessBuilder.Redirect.PIPE);
Process process = builder.start();
this.printProcessOutPut(process);
process.waitFor();
}
public String decideGitBranch(EnvVars env) {
String branch = "";
if (this.gitBranch.equals("")) {
branch = env.get("GIT_BRANCH");
if (branch != null && branch.split("/").length >= 2) {
branch = branch.split("/")[1];
}
} else {
branch = this.gitBranch;
}
return branch;
}
public String decideGitUrl(EnvVars env) {
String url = "";
if (this.gitUrl.equals("")) {
String gitUrlEnv = env.get("GIT_URL");
/* Usual github */
if (!(env.get("GIT_URL") == null && env.get("GIT_URL").equals(""))) {
url = env.get("GIT_URL") + ".git";
/* Git builder */
} else if (!(env.get("ghprbAuthorRepoGitUrl") == null && env.get("ghprbAuthorRepoGitUrl").equals(""))) {
url = env.get("ghprbAuthorRepoGitUrl");
}
} else {
url = this.gitUrl;
}
return url;
}
public boolean authorIsRepairnator(EnvVars env) {
String author = env.get("ghprbActualCommitAuthor") == null ? "" : env.get("ghprbActualCommitAuthor");
if (author.equals("repairnator")) {
System.out.println("The committer is repairnator, no repair will be made");
return true;
}
return false;
}
public boolean isCheckPassed(String branch, String url,EnvVars env) {
/* Error check */
if (authorIsRepairnator(env)) {
return false;
}
if (branch.equals("")) {
System.out.println("ERROR: THE PROVIDED GITBRANCH IS EMPTY");
return false;
}
if (url.equals("")) {
System.out.println("ERROR: THE PROVIDED GITBRANCH IS EMPTY");
return false;
}
if (!(this.useNPEFix || this.useAstorJKali || this.useAstorJMut || this.useNPEFixSafe || this.useNopolTestExclusionStrategy || this.useSorald)) {
System.out.println("ERROR: NO TOOL SPECIFIED , NO NEED TO REPAIR");
return false;
}
return true;
}
public boolean shouldInstallMaven(EnvVars env) {
String m2Home = env.get("M2_HOME");
File maven = new File(config.getMavenHome());
if (m2Home != null) {
this.config.setMavenHome(m2Home);
return false;
}
if (maven.exists()) {
return false;
}
return true;
}
public void configure(String url,String branch, EnvVars env) {
Config config = this.config;
String setupHome = env.get("JENKINS_HOME") + File.separator + "userContent" + File.separator + "RepairnatorSetup";
String javaHome = env.get("JAVA_HOME");
String javaExec = javaHome + File.separator + "bin" + File.separator + "java";
String jarLocation = setupHome + File.separator + "repairnator.jar";
String workspace = env.get("JENKINS_HOME") + File.separator + "userContent" + File.separator + "RepairnatorWorkspace";
File setupDir = new File(setupHome);
if (!setupDir.exists()) {
setupDir.mkdirs();
}
File workspaceDir = new File(workspace);
if (!workspaceDir.exists()) {
workspaceDir.mkdirs();
}
config.setSetupHomePath(setupHome);
config.setJavaExec(javaExec);
config.setJarLocation(jarLocation);
config.setGitUrl(url);
config.setGitBranch(branch);
config.setGitOAuth(this.gitOAuthToken);
config.setTools(this.getTools());
config.setNotifyTo(this.notifyTo);
config.setSonarRules(SonarRulesBlock.constructCmdStr4Rules());
config.setWorkspaceDir(workspaceDir);
}
public void cleanUp(){
try {
FileUtils.cleanDirectory(this.config.getWorkspaceDir());
} catch(Exception e) {
throw new RuntimeException(e);
}
}
public void createGlobalEnvironmentVariables(String key, String value){
Jenkins instance = Jenkins.getInstance();
DescribableList<NodeProperty<?>, NodePropertyDescriptor> globalNodeProperties = instance.getGlobalNodeProperties();
List<EnvironmentVariablesNodeProperty> envVarsNodePropertyList = globalNodeProperties.getAll(EnvironmentVariablesNodeProperty.class);
EnvironmentVariablesNodeProperty newEnvVarsNodeProperty = null;
EnvVars envVars = null;
if ( envVarsNodePropertyList == null || envVarsNodePropertyList.size() == 0 ) {
newEnvVarsNodeProperty = new hudson.slaves.EnvironmentVariablesNodeProperty();
globalNodeProperties.add(newEnvVarsNodeProperty);
envVars = newEnvVarsNodeProperty.getEnvVars();
} else {
envVars = envVarsNodePropertyList.get(0).getEnvVars();
}
envVars.put(key, value);
try {
instance.save();
} catch(Exception e) {
System.out.println("Failed to create env variable");
}
}
private boolean shouldDownloadJar() throws IOException{
File jar = new File(this.getConfig().getJarLocation());
if (jar.exists()) {
BasicFileAttributes attr = Files.readAttributes(jar.toPath(), BasicFileAttributes.class);
Date creationTime = Date.from(attr.creationTime().toInstant());
Date today = Date.from(LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant());
if (Helpers.getDateDiff(creationTime,today,TimeUnit.DAYS) >= 30) { // redownload jar after a month
System.out.println("Jar will be updated");
jar.delete();
return true;
} else {
return false;
}
} else {
System.out.println("Jar does not exist, will proceed downloading Jar ...");
return true;
}
}
@Override
public boolean perform(AbstractBuild build, Launcher launcher, BuildListener listener) {
System.setOut(listener.getLogger());
System.setErr(listener.getLogger());
long startTime = System.currentTimeMillis();
try {
EnvVars env = build.getEnvironment(listener);
String branch = this.decideGitBranch(env);
String url = this.decideGitUrl(env);
if (!this.isCheckPassed(branch,url,env)){
return false;
}
this.configure(url,branch,env);
System.out.println("The following tools will be used : " + Arrays.toString(this.config.getTools()));
System.out.println("workspace for repairnator: " + this.config.getWorkspaceDir().getAbsolutePath());
String snapShotUrl = "https://oss.sonatype.org/content/repositories/snapshots/fr/inria/repairnator/repairnator-pipeline/";
File jar = new File(this.getConfig().getJarLocation());
if (this.shouldDownloadJar()) {
RepairnatorJarDownloader repJarDownloader = new RepairnatorJarDownloader(snapShotUrl,this.getConfig().getJarLocation());
repJarDownloader.download();
}
if (this.shouldInstallMaven(env)) {
System.out.println("M2_HOME is null, proceed installing default maven version 3.6.3");
MavenCustomInstaller mvn = new MavenCustomInstaller(build,listener,config.getMavenHome());
mvn.install();
}
this.runRepairnator(env);
} catch (Exception e) {
throw new RuntimeException(e);
}
this.cleanUp();
long estimatedTime = System.currentTimeMillis() - startTime;
System.out.println("[Total Repair Duration]: " + Util.getTimeSpanString(estimatedTime));
return true;
}
@Override
public DescriptorImpl getDescriptor() {
return (DescriptorImpl) super.getDescriptor();
}
@Override
public BuildStepMonitor getRequiredMonitorService() {
return BuildStepMonitor.NONE;
}
@Override
public Action getProjectAction(AbstractProject<?, ?> project) {
return null;
}
@Extension // This indicates to Jenkins that this is an implementation of an extension point.
public static final class DescriptorImpl extends BuildStepDescriptor<Publisher> {
private boolean useNPEFix;
private boolean useAstorJMut;
private boolean useAstorJKali;
private boolean useNPEFixSafe;
private boolean useNopolTestExclusionStrategy;
private boolean useSorald;
private boolean rulesProvided;
public DescriptorImpl() {
load();
}
public FormValidation doCheckOptions(@QueryParameter boolean useNPEFix, @QueryParameter boolean useAstorJKali, @QueryParameter boolean useAstorJMut,@QueryParameter boolean useNPEFixSafe, @QueryParameter boolean useNopolTestExclusionStrategy,@QueryParameter boolean useSorald) {
if(useSorald) {
FormValidation.warning("Please also provide sonarRules in the textfield below");
}
return FormValidation.ok();
}
public boolean isApplicable(Class<? extends AbstractProject> aClass) {
return true;
}
public String getDisplayName() {
return "Run repairnator";
}
@Override
public boolean configure(StaplerRequest req, JSONObject formData) throws FormException {
req.bindJSON(this, formData);
this.useNPEFix = formData.getBoolean("useNPEFix");
this.useAstorJKali = formData.getBoolean("useAstorJKali");
this.useAstorJMut = formData.getBoolean("useAstorJMut");
this.useNPEFixSafe = formData.getBoolean("useNPEFixSafe");
this.useNopolTestExclusionStrategy = formData.getBoolean("useNopolTestExclusionStrategy");
this.useSorald = formData.getBoolean("useSorald");
save();
return true;
}
public boolean getUseNPEFix() {
return useNPEFix;
}
public boolean getUseAstorJKali() {
return useAstorJKali;
}
public boolean getUseAstorJMut() {
return useAstorJMut;
}
public boolean getUseNPEFixSafe() {
return useNPEFixSafe;
}
public boolean getUseNopolTestExclusionStrategy() {
return useNopolTestExclusionStrategy;
}
public boolean getUseSorald() {
return useSorald;
}
}
public static final class SonarRulesBlock {
public static boolean rulesProvided;
/* Rules */
private static boolean rule1656;
private static boolean rule1854;
private static boolean rule1860;
private static boolean rule1948;
private static boolean rule2095;
private static boolean rule2111;
private static boolean rule2116;
private static boolean rule2164;
private static boolean rule2167;
private static boolean rule2184;
private static boolean rule2204;
private static boolean rule2272;
private static boolean rule3032;
private static boolean rule3067;
private static boolean rule3984;
private static boolean rule4973;
@DataBoundConstructor
public SonarRulesBlock() {}
@DataBoundSetter
public static void setRule1656(boolean rule1656_in) {
rule1656 = rule1656_in;
}
@DataBoundSetter
public static void setRule1854(boolean rule1854_in) {
rule1854 = rule1854_in;
}
@DataBoundSetter
public static void setRule1860(boolean rule1860_in) {
rule1860 = rule1860_in;
}
@DataBoundSetter
public static void setRule1948(boolean rule1948_in) {
rule1948 = rule1948_in;
}
@DataBoundSetter
public static void setRule2095(boolean rule2095_in) {
rule2095 = rule2095_in;
}
@DataBoundSetter
public static void setRule2111(boolean rule2111_in) {
rule2111 = rule2111_in;
}
@DataBoundSetter
public static void setRule2116(boolean rule2116_in) {
rule2116 = rule2116_in;
}
@DataBoundSetter
public static void setRule2164(boolean rule2164_in) {
rule2164 = rule2164_in;
}
@DataBoundSetter
public static void setRule2167(boolean rule2167_in) {
rule2167 = rule2167_in;
}
@DataBoundSetter
public static void setRule2184(boolean rule2184_in) {
rule2184 = rule2184_in;
}
@DataBoundSetter
public static void setRule2204(boolean rule2204_in) {
rule2204 = rule2204_in;
}
@DataBoundSetter
public static void setRule2272(boolean rule2272_in) {
rule2272 = rule2272_in;
}
@DataBoundSetter
public static void setRule3032(boolean rule3032_in) {
rule3032 = rule3032_in;
}
@DataBoundSetter
public static void setRule3067(boolean rule3067_in) {
rule3067 = rule3067_in;
}
@DataBoundSetter
public static void setRule3984(boolean rule3984_in) {
rule3984 = rule3984_in;
}
@DataBoundSetter
public static void setRule4973(boolean rule4973_in) {
rule4973 = rule4973_in;
}
private static String ruleStringOrEmpty(boolean rule,String ruleNumber) {
if (rule) {
return ruleNumber + ",";
}
return "";
}
public static String constructCmdStr4Rules() {
StringBuilder sb = new StringBuilder();
sb.append(ruleStringOrEmpty(rule1656,"1656"))
.append(ruleStringOrEmpty(rule1854,"1854"))
.append(ruleStringOrEmpty(rule1860,"1860"))
.append(ruleStringOrEmpty(rule1948,"1948"))
.append(ruleStringOrEmpty(rule2095,"2095"))
.append(ruleStringOrEmpty(rule2111,"2111"))
.append(ruleStringOrEmpty(rule2116,"2116"))
.append(ruleStringOrEmpty(rule2164,"2164"))
.append(ruleStringOrEmpty(rule2167,"2167"))
.append(ruleStringOrEmpty(rule2184,"2184"))
.append(ruleStringOrEmpty(rule2204,"2204"))
.append(ruleStringOrEmpty(rule2272,"2272"))
.append(ruleStringOrEmpty(rule3032,"3032"))
.append(ruleStringOrEmpty(rule3067,"3067"))
.append(ruleStringOrEmpty(rule3984,"3984"))
.append(ruleStringOrEmpty(rule4973,"4973"));
String res = sb.toString();
if (!res.equals("")) {
return res.substring(0,res.length() - 1); // remove last character ','
}
return "";
}
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.paths;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutType;
import fr.inria.spirals.repairnator.process.utils4tests.ProjectInspectorMocker;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
public class TestComputePlugins {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig.getInstance().setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Ignore("Test on Travis, not valid project")
@Test
public void testComputePluginsWithSingleModuleProject() throws IOException {
long buggyBuildCandidateId = 224442109; // repairnator/failingProject -> plugins
Build buggyBuildCandidate = this.checkBuildAndReturn(buggyBuildCandidateId, false);
BuildToBeInspected buildToBeInspected = new BuildToBeInspected(buggyBuildCandidate, null, ScannedBuildStatus.ONLY_FAIL, "test");
tmpDir = Files.createTempDirectory("test_compute_plugins_with_single_module_project").toFile();
File repoDir = new File(tmpDir, "repo");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
jobStatus.setFailingModulePath(repoDir.getAbsolutePath());
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, buildToBeInspected, CheckoutType.CHECKOUT_BUGGY_BUILD);
CloneRepository cloneStep = new CloneRepository(inspector);
ComputePlugins computePlugins = new ComputePlugins(inspector, true);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true)).addNextStep(computePlugins);
cloneStep.execute();
assertThat(computePlugins.isShouldStop(), is(false));
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertThat(stepStatusList.size(), is(3));
StepStatus classpathStatus = stepStatusList.get(2);
assertThat(classpathStatus.getStep(), is(computePlugins));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
assertThat(jobStatus.getProperties().getProjectMetrics().getNumberPlugins(), is(1));
}
@Ignore("Test on Travis, not valid project")
@Test
public void testComputePluginsWithNoPlugin() throws IOException {
long buggyBuildCandidateId = 224246334; // repairnator/failingProject -> master
Build buggyBuildCandidate = this.checkBuildAndReturn(buggyBuildCandidateId, false);
BuildToBeInspected buildToBeInspected = new BuildToBeInspected(buggyBuildCandidate, null, ScannedBuildStatus.ONLY_FAIL, "test");
tmpDir = Files.createTempDirectory("test_compute_plugins_with_single_module_project").toFile();
File repoDir = new File(tmpDir, "repo");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
jobStatus.setFailingModulePath(repoDir.getAbsolutePath());
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, buildToBeInspected, CheckoutType.CHECKOUT_BUGGY_BUILD);
CloneRepository cloneStep = new CloneRepository(inspector);
ComputePlugins computePlugins = new ComputePlugins(inspector, true);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true)).addNextStep(computePlugins);
cloneStep.execute();
assertThat(computePlugins.isShouldStop(), is(false));
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertThat(stepStatusList.size(), is(3));
StepStatus classpathStatus = stepStatusList.get(2);
assertThat(classpathStatus.getStep(), is(computePlugins));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
assertThat(jobStatus.getProperties().getProjectMetrics().getNumberPlugins(), is(0));
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.paths;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.maven.MavenHelper;
import fr.inria.spirals.repairnator.process.step.AbstractStep;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.states.PipelineState;
import org.apache.maven.model.Model;
import org.apache.maven.model.Plugin;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
* Created by bloriot97 on 01/11/2018.
* This step compute the projects plugins.
*/
public class ComputePlugins extends AbstractStep {
public ComputePlugins(ProjectInspector inspector, boolean blockingStep) {
super(inspector, blockingStep);
}
private List<Plugin> findPlugins(String pomPath) {
List<File> plugins = new ArrayList<>();
File pomFile = new File(pomPath);
Model model = MavenHelper.readPomXml(pomFile, this.getInspector().getM2LocalPath());
if (model == null) {
this.addStepError("Error while building model: no model has been retrieved.");
return null;
}
if (model.getBuild() == null) {
this.addStepError("Error while obtaining build from pom.xml: build section has not been found.");
return null;
}
if (model.getBuild().getPlugins() == null) {
this.addStepError("Error while obtaining plugins from pom.xml: plugin section has not been found.");
return null;
}
return model.getBuild().getPlugins();
}
@Override
protected StepStatus businessExecute() {
this.getLogger().debug("Computing project plugins...");
String mainPomPath = this.getPom();
List<Plugin> plugins = this.findPlugins(mainPomPath);
if (plugins == null) {
this.getLogger().info("No plugins was found.");
return StepStatus.buildError(this, PipelineState.PLUGINSNOTCOMPUTED);
} else if (plugins.size() == 0) {
this.getLogger().info("No plugins was found.");
}
this.getInspector().getJobStatus().setPlugins(plugins);
this.getInspector().getJobStatus().getProperties().getProjectMetrics().setNumberPlugins(plugins.size());
return StepStatus.buildSuccess(this);
}
}
```
|
```package fr.inria.spirals.repairnator.process.step;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutType;
import fr.inria.spirals.repairnator.process.utils4tests.ProjectInspectorMocker;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;
/**
* Created by urli on 07/03/2017.
*/
public class TestBuildProject {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Test
@Ignore
//FIXME: We can't rely on repairnator/failing project to get builds
public void testBuildProject() throws IOException {
// slug y commit hash
long buildId = 220946365; // repairnator/failingProject erroring-branch
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_build").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, toBeInspected, CheckoutType.CHECKOUT_BUGGY_BUILD);
CloneRepository cloneStep = new CloneRepository(inspector);
BuildProject buildStep = new BuildProject(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true)).addNextStep(buildStep);
cloneStep.execute();
assertFalse(buildStep.isShouldStop());
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertEquals(stepStatusList.size(), 3);
StepStatus statusBuild = stepStatusList.get(2);
assertEquals(statusBuild.getStep(), buildStep);
for (StepStatus stepStatus : stepStatusList) {
assertTrue(stepStatus.isSuccess());
}
}
@Test
@Ignore
//FIXME: We can't rely on repairnator/failing project to get builds
public void testBuildProjectWithPomNotInRoot() throws IOException {
long buildId = 220957920; // repairnator/failingProject other-directory-for-pom-file
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_build").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), Collections.EMPTY_LIST, Collections.EMPTY_LIST);
JobStatus jobStatus = inspector.getJobStatus();
CloneRepository cloneStep = new CloneRepository(inspector);
BuildProject buildStep = new BuildProject(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true)).addNextStep(buildStep);
cloneStep.execute();
assertFalse(buildStep.isShouldStop());
List<StepStatus> stepStatusList = jobStatus.getStepStatuses();
assertEquals(stepStatusList.size(),3);
StepStatus statusBuild = stepStatusList.get(2);
assertEquals(statusBuild.getStep(), buildStep);
for (StepStatus stepStatus : stepStatusList) {
assertTrue(stepStatus.isSuccess());
}
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertNotNull(build);
assertEquals(buildId, build.getId());
assertEquals(build.isPullRequest(), isPR);
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.maven.MavenHelper;
import fr.inria.spirals.repairnator.states.PipelineState;
import java.util.Properties;
/**
* Created by urli on 03/01/2017.
*/
public class BuildProject extends AbstractStep {
public BuildProject(ProjectInspector inspector) {
super(inspector, true);
}
public BuildProject(ProjectInspector inspector, boolean blockingStep) {
super(inspector, blockingStep);
}
public BuildProject(ProjectInspector inspector, boolean blockingStep, String stepName) {
super(inspector, blockingStep, stepName);
}
protected StepStatus businessExecute() {
this.getLogger().debug("Building project by installing artifacts with maven (skip test execution)...");
Properties properties = new Properties();
properties.setProperty(MavenHelper.SKIP_TEST_PROPERTY, "true");
MavenHelper helper = new MavenHelper(this.getPom(), "install", properties, this.getClass().getSimpleName(), this.getInspector(), true);
int result;
try {
result = helper.run();
} catch (InterruptedException e) {
this.addStepError("Error while building", e);
result = MavenHelper.MAVEN_ERROR;
}
if (result == MavenHelper.MAVEN_SUCCESS) {
return StepStatus.buildSuccess(this);
} else {
this.addStepError("Repository " + this.getInspector().getRepoSlug() + " cannot be built.");
return StepStatus.buildError(this, PipelineState.NOTBUILDABLE);
}
}
}
```
|
```package fr.inria.spirals.repairnator.process.utils4tests;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.git.GitHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutType;
import java.io.File;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class ProjectInspectorMocker {
public static ProjectInspector mockProjectInspector(JobStatus jobStatus) {
ProjectInspector inspector = mock(ProjectInspector.class);
when(inspector.getJobStatus()).thenReturn(jobStatus);
return inspector;
}
public static ProjectInspector mockProjectInspector(JobStatus jobStatus, String localRepoPath) {
ProjectInspector inspector = mockProjectInspector(jobStatus);
when(inspector.getRepoLocalPath()).thenReturn(localRepoPath);
return inspector;
}
public static ProjectInspector mockProjectInspector(JobStatus jobStatus, File tmpDir, BuildToBeInspected buildToBeInspected) {
ProjectInspector inspector = mockProjectInspector(jobStatus);
when(inspector.getRepoSlug()).thenReturn(buildToBeInspected.getBuggyBuild().getRepository().getSlug());
when(inspector.getWorkspace()).thenReturn(tmpDir.getAbsolutePath());
when(inspector.getRepoLocalPath()).thenReturn(tmpDir.getAbsolutePath()+"/repo");
when(inspector.getRepoToPushLocalPath()).thenReturn(tmpDir.getAbsolutePath()+"/repotopush");
when(inspector.getBuildToBeInspected()).thenReturn(buildToBeInspected);
when(inspector.getBuggyBuild()).thenReturn(buildToBeInspected.getBuggyBuild());
when(inspector.getPatchedBuild()).thenReturn(buildToBeInspected.getPatchedBuild());
when(inspector.getM2LocalPath()).thenReturn(tmpDir.getAbsolutePath()+"/.m2");
when(inspector.getGitHelper()).thenReturn(new GitHelper());
return inspector;
}
public static ProjectInspector mockProjectInspector(JobStatus jobStatus, File tmpDir, BuildToBeInspected buildToBeInspected, CheckoutType checkoutType) {
ProjectInspector inspector = mockProjectInspector(jobStatus, tmpDir, buildToBeInspected);
when(inspector.getCheckoutType()).thenReturn(checkoutType);
return inspector;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.inspectors;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.notifier.AbstractNotifier;
import fr.inria.spirals.repairnator.notifier.ErrorNotifier;
import fr.inria.spirals.repairnator.notifier.PatchNotifier;
import fr.inria.spirals.repairnator.pipeline.RepairToolsManager;
import fr.inria.spirals.repairnator.process.git.GitHelper;
import fr.inria.spirals.repairnator.process.inspectors.properties.Properties;
import fr.inria.spirals.repairnator.process.inspectors.properties.machineInfo.MachineInfo;
import fr.inria.spirals.repairnator.process.step.AbstractStep;
import fr.inria.spirals.repairnator.process.step.AddExperimentalPluginRepo;
import fr.inria.spirals.repairnator.process.step.BuildProject;
import fr.inria.spirals.repairnator.process.step.JenkinsCloneRepository;
import fr.inria.spirals.repairnator.process.step.TestProject;
import fr.inria.spirals.repairnator.process.step.WritePropertyFile;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutPatchedBuild;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutType;
import fr.inria.spirals.repairnator.process.step.gatherinfo.BuildShouldFail;
import fr.inria.spirals.repairnator.process.step.gatherinfo.BuildShouldPass;
import fr.inria.spirals.repairnator.process.step.gatherinfo.GatherTestInformation;
import fr.inria.spirals.repairnator.process.step.paths.ComputeClasspath;
import fr.inria.spirals.repairnator.process.step.paths.ComputeModules;
import fr.inria.spirals.repairnator.process.step.paths.ComputeSourceDir;
import fr.inria.spirals.repairnator.process.step.paths.ComputeTestDir;
import fr.inria.spirals.repairnator.process.step.push.CommitPatch;
import fr.inria.spirals.repairnator.process.step.push.CommitProcessEnd;
import fr.inria.spirals.repairnator.process.step.push.CommitType;
import fr.inria.spirals.repairnator.process.step.push.InitRepoToPush;
import fr.inria.spirals.repairnator.process.step.push.PushProcessEnd;
import fr.inria.spirals.repairnator.process.step.repair.AbstractRepairStep;
import fr.inria.spirals.repairnator.serializer.AbstractDataSerializer;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import fr.inria.spirals.repairnator.utils.Utils;
import org.kohsuke.github.GHRepository;
import org.kohsuke.github.GitHub;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* This class initialize the pipelines by creating the steps:
* it's the backbone of the pipeline.
*/
public class JenkinsProjectInspector extends ProjectInspector{
private final Logger logger = LoggerFactory.getLogger(ProjectInspector.class);
private GitHelper gitHelper;
private BuildToBeInspected buildToBeInspected;
private String gitUrl;
private String gitSlug;
private String gitBranch;
private String gitCommit;
private String repoLocalPath;
private String repoToPushLocalPath;
private String workspace;
private String m2LocalPath;
private List<AbstractDataSerializer> serializers;
private JobStatus jobStatus;
private List<AbstractNotifier> notifiers;
private PatchNotifier patchNotifier;
private CheckoutType checkoutType;
private List<AbstractStep> steps;
private AbstractStep finalStep;
private boolean pipelineEnding;
public JenkinsProjectInspector(BuildToBeInspected buildToBeInspected, String workspace, List<AbstractDataSerializer> serializers, List<AbstractNotifier> notifiers) {
super(buildToBeInspected,workspace,serializers,notifiers);
}
public JenkinsProjectInspector(String workspace,String gitUrl,String gitBranch,String gitCommit,List<AbstractDataSerializer> serializers, List<AbstractNotifier> notifiers) {
super(workspace,gitUrl,gitBranch,gitCommit,serializers,notifiers);
this.gitUrl = gitUrl;
this.gitBranch = gitBranch;
this.gitCommit = gitCommit;
this.gitSlug = this.gitUrl.split("https://github.com/",2)[1].replace(".git","");
this.workspace = workspace;
this.repoLocalPath = workspace + File.separator + this.getRepoSlug();
this.repoToPushLocalPath = repoLocalPath+"_topush";
this.m2LocalPath = new File(this.repoLocalPath + File.separator + ".m2").getAbsolutePath();
this.serializers = null;
this.gitHelper = new GitHelper();
this.jobStatus = new JobStatus(repoLocalPath);
this.notifiers = notifiers;
this.checkoutType = CheckoutType.NO_CHECKOUT;
this.steps = new ArrayList<>();
this.initProperties();
}
/* This is the new branch for end process */
@Override
public String getRemoteBranchName() {
return this.getRepoSlug().replace('/', '-');
}
@Override
public String getRepoSlug() {
return this.gitSlug;
}
public String getGitUrl() {
return this.gitUrl;
}
/* This is the branch , which repairnator will repair*/
public String getCheckoutBranchName() {
return this.gitBranch;
}
public String getGitCommit() {
return this.gitCommit;
}
@Override
protected void initProperties() {
try {
Properties properties = this.jobStatus.getProperties();
/* ProcessDurations use checkoutBuggyBuild*/
fr.inria.spirals.repairnator.process.inspectors.properties.repository.Repository repository = properties.getRepository();
repository.setName(this.getRepoSlug());
repository.setUrl(this.getGitUrl());
GitHub gitHub;
try {
gitHub = RepairnatorConfig.getInstance().getGithub();
GHRepository repo = gitHub.getRepository(this.getRepoSlug());
repository.setGithubId(repo.getId());
if (repo.isFork()) {
repository.setIsFork(true);
repository.getOriginal().setName(repo.getParent().getFullName());
repository.getOriginal().setGithubId(repo.getParent().getId());
repository.getOriginal().setUrl(Utils.getSimpleGithubRepoUrl(repo.getParent().getFullName()));
}
} catch (IOException e) {
this.logger.warn("It was not possible to retrieve information to check if " + this.getRepoSlug() + " is a fork.");
this.logger.debug(e.toString());
}
} catch (Exception e) {
this.logger.error("Error while initializing metrics.", e);
}
}
public String getRepoLocalPath() {
return this.repoLocalPath;
}
public void run() {
AbstractStep cloneRepo = new JenkinsCloneRepository(this);
// If we have experimental plugins, we need to add them here.
String[] repos = RepairnatorConfig.getInstance().getExperimentalPluginRepoList();
if(repos != null) {
for(int i = 0; i < repos.length-1; i =+ 2) {
cloneRepo.addNextStep(new AddExperimentalPluginRepo(this, repos[i], repos[i+1], repos[i+2]));
}
}
cloneRepo
.addNextStep(new BuildProject(this))
.addNextStep(new TestProject(this))
.addNextStep(new GatherTestInformation(this, true, new BuildShouldFail(), false))
.addNextStep(new InitRepoToPush(this))
.addNextStep(new ComputeClasspath(this, false))
.addNextStep(new ComputeSourceDir(this, false, false))
.addNextStep(new ComputeTestDir(this, false));
for (String repairToolName : RepairnatorConfig.getInstance().getRepairTools()) {
AbstractRepairStep repairStep = RepairToolsManager.getStepFromName(repairToolName);
if (repairStep != null) {
repairStep.setProjectInspector(this);
cloneRepo.addNextStep(repairStep);
} else {
logger.error("Error while getting repair step class for following name: " + repairToolName);
}
}
cloneRepo.addNextStep(new CommitPatch(this, CommitType.COMMIT_REPAIR_INFO))
.addNextStep(new CheckoutPatchedBuild(this, true))
.addNextStep(new BuildProject(this))
.addNextStep(new TestProject(this))
.addNextStep(new GatherTestInformation(this, true, new BuildShouldPass(), true))
.addNextStep(new CommitPatch(this, CommitType.COMMIT_HUMAN_PATCH));
this.finalStep = new ComputeSourceDir(this, false, true); // this step is used to compute code metrics on the project
this.finalStep.
addNextStep(new ComputeModules(this, false)).
addNextStep(new WritePropertyFile(this)).
addNextStep(new CommitProcessEnd(this)).
addNextStep(new PushProcessEnd(this));
cloneRepo.setDataSerializer(this.serializers);
cloneRepo.setNotifiers(this.notifiers);
this.printPipeline();
try {
cloneRepo.execute();
} catch (Exception e) {
this.jobStatus.addStepError("Unknown", e.getMessage());
this.logger.error("Exception catch while executing steps: ", e);
this.jobStatus.setFatalError(e);
ErrorNotifier errorNotifier = ErrorNotifier.getInstance();
if (errorNotifier != null) {
errorNotifier.observe(this);
}
for (AbstractDataSerializer serializer : this.serializers) {
serializer.serialize();
}
}
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.repair;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.inspectors.RepairPatch;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.AddExperimentalPluginRepo;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.TestProject;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.gatherinfo.BuildShouldFail;
import fr.inria.spirals.repairnator.process.step.gatherinfo.GatherTestInformation;
import fr.inria.spirals.repairnator.serializer.AbstractDataSerializer;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
/**
* Tests the safe mode of NpeFix
*/
public class TestNPERepairSafe {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
// @Test breaks CI in Jan 2020
public void testNPERepairSafe() throws IOException {
long buildId = 252712792; // surli/failingProject build
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_nperepairsafe").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
RepairnatorConfig.getInstance().setRepairTools(Collections.singleton(NPERepairSafe.TOOL_NAME));
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
NPERepairSafe npeRepair = new NPERepairSafe();
npeRepair.setProjectInspector(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new AddExperimentalPluginRepo(inspector, "ExperimentalNPEFixSafe", "repairnator.proj.kth", "http://repairnator.proj.kth.se:55555/"))
.addNextStep(new TestProject(inspector))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(npeRepair);
cloneStep.execute();
assertThat(npeRepair.isShouldStop(), is(false));
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertThat(stepStatusList.size(), is(6));
StepStatus npeStatus = stepStatusList.get(5);
assertThat(npeStatus.getStep(), is(npeRepair));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
String finalStatus = AbstractDataSerializer.getPrettyPrintState(inspector);
assertThat(finalStatus, is("PATCHED"));
List<RepairPatch> allPatches = inspector.getJobStatus().getAllPatches();
assertThat(allPatches.size(), is(6));
assertThat(inspector.getJobStatus().getToolDiagnostic().get(npeRepair.getRepairToolName()), notNullValue());
for (RepairPatch repairPatch : allPatches) {
assertTrue(new File(repairPatch.getFilePath()).exists());
}
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.repair;
import fr.inria.spirals.repairnator.process.step.StepStatus;
/**
* Created by Benjamin Tellström on 14/06/2019
*
* Refactored by andre15silva on 16/01/2021
*/
public class NPERepairSafe extends AbstractNPERepairStep {
public static final String TOOL_NAME = "NPEFixSafe";
public NPERepairSafe() {
super();
this.selection = "safe-mono";
}
@Override
public String getRepairToolName() {
return TOOL_NAME;
}
@Override
protected StepStatus businessExecute() {
return super.businessExecute();
}
}
```
|
```package fr.inria.spirals.repairnator.pipeline;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.notifier.PatchNotifier;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.inspectors.RepairPatch;
import org.junit.After;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class TestPipeline {
@Rule
public TemporaryFolder workspaceFolder = new TemporaryFolder();
@Rule
public TemporaryFolder outputFolder = new TemporaryFolder();
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
}
@Test
@Ignore //while fixing CI
public void testPipeline() throws Exception {
// requires env variable M2_HOME and GITHUB_OAUTH
// (set in Travis config)
// eg export M2_HOME=/usr/share/maven
// from repairnator/failingBuild
Launcher l = new Launcher(new String[]{
"--jtravisendpoint", "https://api.travis-ci.com",
"--build", "220925392", //rerun onn 20-12-2022
"--repairTools", "NPEFix",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
Patches patchNotifier = new Patches();
l.setPatchNotifier(patchNotifier);
l.mainProcess();
assertEquals("PATCHED", l.getInspector().getFinding());
assertEquals(10, patchNotifier.allpatches.size());
assertTrue("patch is found", patchNotifier.allpatches.get(0).getDiff().contains("list == null"));
}
@Test
@Ignore //while fixing CI
public void testPipelineOnlyGitRepository() throws Exception {
Launcher l = new Launcher(new String[]{
"--gitrepourl", "https://github.com/repairnator/failingProject",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath(),
"--launcherMode", "GIT_REPOSITORY"
});
Patches patchNotifier = new Patches();
l.setPatchNotifier(patchNotifier);
l.mainProcess();
assertEquals("PATCHED", l.getInspector().getFinding());
assertEquals(10, patchNotifier.allpatches.size());
assertTrue("patch is found", patchNotifier.allpatches.get(0).getDiff().contains("list == null"));
}
@Test
@Ignore //while fixing CI
public void testPipelineGitRepositoryAndBranch() throws Exception {
Launcher l = new Launcher(new String[]{
"--gitrepourl", "https://github.com/repairnator/failingProject",
"--gitrepobranch", "astor-jkali-failure",
"--repairTools", "AstorJKali",
"--launcherMode", "GIT_REPOSITORY",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
l.mainProcess();
assertEquals("TEST FAILURE", l.getInspector().getFinding());
}
@Test
@Ignore //while fixing CI
public void testPipelineGitRepositoryAndCommitIdWithFailure() throws Exception {
Launcher l = new Launcher(new String[]{
"--gitrepourl", "https://github.com/repairnator/failingProject",
"--gitrepobranch", "no-infinite-loop",
"--launcherMode", "GIT_REPOSITORY",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
l.mainProcess();
assertEquals("TEST FAILURE", l.getInspector().getFinding());
}
@Test
@Ignore //while fixing CI
public void testPipelineGitRepositoryAndCommitIdWithSuccess() throws Exception {
Launcher l = new Launcher(new String[]{
"--gitrepourl", "https://github.com/repairnator/failingProject",
"--gitrepoidcommit", "7e1837df8db7a563fba65f75f7f477c43c9c75e9",
"--launcherMode", "GIT_REPOSITORY",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
Patches patchNotifier = new Patches();
l.setPatchNotifier(patchNotifier);
l.mainProcess();
assertEquals("PATCHED", l.getInspector().getFinding());
assertEquals(10, patchNotifier.allpatches.size());
assertTrue("patch is found", patchNotifier.allpatches.get(0).getDiff().contains("list == null"));
}
@Ignore
@Test
public void testPipelineGitRepositoryFirstCommit() throws Exception {
Launcher l = new Launcher(new String[]{
"--gitrepourl", "https://github.com/repairnator/failingProject",
"--gitrepofirstcommit",
"--launcherMode", "GIT_REPOSITORY",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
l.mainProcess();
assertEquals("NOTBUILDABLE", l.getInspector().getFinding());
}
class Patches implements PatchNotifier {
List<RepairPatch> allpatches = new ArrayList<>();
@Override
public void notify(ProjectInspector inspector, String toolname, List<RepairPatch> patches) {
allpatches.addAll(patches);
}
}
@Ignore
@Test
public void testPRLuc12() throws Exception {
// reproducing the 12th PR of Luc
// see https://github.com/eclipse/repairnator/issues/758
Launcher l = new Launcher(new String[]{
"--build", "395891390",
"--repairTools", "NPEFix",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
Patches patchNotifier = new Patches();
l.setPatchNotifier(patchNotifier);
l.mainProcess();
assertEquals("PATCHED", l.getInspector().getFinding());
assertEquals(1, patchNotifier.allpatches.size());
assertTrue("patch is found", patchNotifier.allpatches.get(0).getDiff().contains("hashtagStore != null"));
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.inspectors.properties.patchDiff;
public class Lines {
private int numberAdded;
private int numberDeleted;
public Lines() {}
public int getNumberAdded() {
return numberAdded;
}
public void setNumberAdded(int numberAdded) {
this.numberAdded = numberAdded;
}
public int getNumberDeleted() {
return numberDeleted;
}
public void setNumberDeleted(int numberDeleted) {
this.numberDeleted = numberDeleted;
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.faultLocalization;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.TestProject;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.gatherinfo.BuildShouldFail;
import fr.inria.spirals.repairnator.process.step.gatherinfo.GatherTestInformation;
import fr.inria.spirals.repairnator.process.step.paths.ComputeClasspath;
import fr.inria.spirals.repairnator.process.step.paths.ComputeSourceDir;
import fr.inria.spirals.repairnator.process.step.paths.ComputeTestDir;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.spoonlabs.flacoco.api.result.Location;
import fr.spoonlabs.flacoco.api.result.Suspiciousness;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.*;
import org.junit.rules.TemporaryFolder;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
public class TestFlacocoLocalization {
@Rule
public TemporaryFolder workspaceFolder = new TemporaryFolder();
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setJTravisEndpoint("https://api.travis-ci.com");
config.setFlacocoThreshold(0.5);
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
}
@Test
@Ignore
//TODO: Add a test with a failing build from GitHub Actions
public void testFlacocoLocalization() throws IOException {
long buildId = 236072272; // repairnator/failingProject build
Build build = this.checkBuildAndReturn(buildId, true);
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
ProjectInspector inspector = new ProjectInspector(toBeInspected, workspaceFolder.getRoot().getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
FlacocoLocalization flacocoLocalization = new FlacocoLocalization(inspector, true);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new TestProject(inspector))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(new ComputeClasspath(inspector, true))
.addNextStep(new ComputeSourceDir(inspector, true, false))
.addNextStep(new ComputeTestDir(inspector, true))
.addNextStep(flacocoLocalization);
cloneStep.execute();
assertThat(flacocoLocalization.isShouldStop(), is(false));
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertThat(stepStatusList.size(), is(8));
StepStatus assertFixerStatus = stepStatusList.get(7);
assertThat(assertFixerStatus.getStep(), is(flacocoLocalization));
for (StepStatus stepStatus : stepStatusList) {
assertThat("Failing step :" + stepStatus, stepStatus.isSuccess(), is(true));
}
// assert that fault localization results are stored
Map<Location, Suspiciousness> results = inspector.getJobStatus().getFlacocoResult().getDefaultSuspiciousnessMap();
assertThat(results, notNullValue());
assertThat(results.size(), is(4));
assertThat(results.get(new Location("nopol_examples.nopol_example_3.NopolExample", 3)), notNullValue());
assertThat(results.get(new Location("nopol_examples.nopol_example_3.NopolExample", 9)), notNullValue());
assertThat(results.get(new Location("nopol_examples.nopol_example_3.NopolExample", 10)), notNullValue());
assertThat(results.get(new Location("nopol_examples.nopol_example_3.NopolExample", 12)), notNullValue());
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.faultLocalization;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.AbstractStep;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.spoonlabs.flacoco.api.Flacoco;
import fr.spoonlabs.flacoco.api.result.FlacocoResult;
import fr.spoonlabs.flacoco.core.config.FlacocoConfig;
import java.io.File;
import java.net.URL;
public class FlacocoLocalization extends AbstractStep {
public FlacocoLocalization(ProjectInspector inspector, boolean blockingStep) {
super(inspector, blockingStep);
}
public FlacocoLocalization(ProjectInspector inspector, boolean blockingStep, String name) {
super(inspector, blockingStep, name);
}
@Override
protected StepStatus businessExecute() {
FlacocoConfig config = setupFlacocoConfig();
Flacoco flacoco = new Flacoco(config);
FlacocoResult result = flacoco.run();
this.getLogger().debug("Results from flacoco: " + result.getDefaultSuspiciousnessMap().toString());
this.getInspector().getJobStatus().setFlacocoResult(result);
return StepStatus.buildSuccess(this);
}
private FlacocoConfig setupFlacocoConfig() {
FlacocoConfig flacocoConfig = new FlacocoConfig();
JobStatus jobStatus = this.getInspector().getJobStatus();
flacocoConfig.setProjectPath(jobStatus.getFailingModulePath());
flacocoConfig.setClasspath(jobStatus.getRepairClassPath().stream()
.map(URL::getPath).reduce((x, y) -> x + File.pathSeparator + y).orElse(""));
flacocoConfig.setThreshold(RepairnatorConfig.getInstance().getFlacocoThreshold());
return flacocoConfig;
}
}```
|
```package fr.inria.spirals.repairnator.process.git;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.properties.Properties;
import fr.inria.spirals.repairnator.process.inspectors.properties.patchDiff.PatchDiff;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import org.junit.After;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import static org.junit.Assert.assertEquals;
public class GitHelperTest {
private File tmpDir;
@After
public void tearDown() throws IOException {
FileHelper.deleteFile(tmpDir);
}
@Test
public void testcomputePatchStats() throws GitAPIException, IOException {
JobStatus jobStatus = new JobStatus("fakePomDirPath");
String remoteRepo = "https://github.com/Spirals-Team/jtravis.git";
String parentCommit = "2d65266f9a52b27f955ec9a74aa9ab4dac5537d7";
String commit = "f267c73200e2ebb9431d6ffe80e507222567696c"; // GH says: 14 changed files, 443 additions, 104 deletions,
// on java files is: 13 changed files, 405 additions, 104 deletions
tmpDir = java.nio.file.Files.createTempDirectory("jtravis").toFile();
Git git = Git.cloneRepository().setURI(remoteRepo).setBranch("master").setDirectory(tmpDir).call();
RevWalk revwalk = new RevWalk(git.getRepository());
RevCommit revParentCommit = revwalk.parseCommit(ObjectId.fromString(parentCommit));
RevCommit revCommit = revwalk.parseCommit(ObjectId.fromString(commit));
GitHelper gitHelper = new GitHelper();
gitHelper.computePatchStats(jobStatus, git, revCommit, revParentCommit);
PatchDiff patchDiff = jobStatus.getProperties().getPatchDiff();
assertEquals(8, patchDiff.getFiles().getNumberAdded());
assertEquals(1, patchDiff.getFiles().getNumberDeleted());
assertEquals(4, patchDiff.getFiles().getNumberChanged());
assertEquals(405, patchDiff.getLines().getNumberAdded());
assertEquals(104, patchDiff.getLines().getNumberDeleted());
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.git;
import fr.inria.jtravis.entities.Build;
import fr.inria.jtravis.entities.PullRequest;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.properties.patchDiff.PatchDiff;
import fr.inria.spirals.repairnator.process.step.AbstractStep;
import org.apache.commons.lang.StringUtils;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.MergeCommand;
import org.eclipse.jgit.api.MergeResult;
import org.eclipse.jgit.api.RemoteAddCommand;
import org.eclipse.jgit.api.Status;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.DiffFormatter;
import org.eclipse.jgit.diff.Edit;
import org.eclipse.jgit.diff.EditList;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.patch.FileHeader;
import org.eclipse.jgit.patch.HunkHeader;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.transport.URIish;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;
import org.eclipse.jgit.util.io.DisabledOutputStream;
import org.kohsuke.github.GHCommit;
import org.kohsuke.github.GHRateLimit;
import org.kohsuke.github.GHRepository;
import org.kohsuke.github.GitHub;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Created by fernanda on 01/03/17.
*/
public class GitHelper {
private int nbCommits;
private static PersonIdent committerIdent;
public GitHelper() {
this.nbCommits = 0;
}
public int getNbCommits() {
return nbCommits;
}
private static Logger getLogger() {
return LoggerFactory.getLogger(GitHelper.class);
}
/**
* Test if a commit exists in the given git repository
*
* @param git
* @param oldCommitSha
* @return oldCommitSha if the commit exists in the repo, a new commit SHA
* if the commit has been retrieved from GitHub and applied back, or
* null if the retrieve failed.
*/
public String testCommitExistence(Git git, String oldCommitSha, AbstractStep step, Build build) {
try {
ObjectId commitObject = git.getRepository().resolve(oldCommitSha);
git.getRepository().open(commitObject);
return oldCommitSha;
} catch (IOException e) {
step.addStepError("Error while testing commit: " + e);
if (!build.getBranch().isExistsOnGithub()) {
step.addStepError("The commit can't be resolved because the branch where such commit was done does not exist in GitHub anymore: " + Utils.getBranchUrl(build.getBranch().getName(), build.getRepository().getSlug()));
}
}
return null;
}
public static PersonIdent getCommitterIdent() {
if (committerIdent == null) {
committerIdent = new PersonIdent(RepairnatorConfig.getInstance().getGithubUserName(), RepairnatorConfig.getInstance().getGithubUserEmail());
}
return committerIdent;
}
public boolean addAndCommitRepairnatorLogAndProperties(JobStatus status, Git git, String commitMsg) {
if (!RepairnatorConfig.getInstance().isPush()) {
return false;
}
try {
Status gitStatus = git.status().call();
if (!gitStatus.isClean()) {
this.getLogger().debug("Commit repairnator files...");
List<String> filesChanged = new ArrayList<>();
filesChanged.addAll(gitStatus.getUncommittedChanges());
filesChanged.addAll(gitStatus.getUntracked());
filesChanged.addAll(gitStatus.getUntrackedFolders());
List<String> filesToAdd = new ArrayList<>(status.getCreatedFilesToPush());
List<String> filesToCheckout = new ArrayList<>();
for (String fileName : filesChanged) {
if (!status.isCreatedFileToPush(fileName)) {
filesToCheckout.add(fileName);
} else {
filesToAdd.add(fileName);
}
}
if (filesToAdd.isEmpty()) {
this.getLogger().info("There is no repairnator file to commit.");
return false;
}
this.getLogger().info(filesToAdd.size()+" repairnator files to commit.");
if (!filesToCheckout.isEmpty()) {
this.getLogger().debug("Checkout "+filesToCheckout.size()+" files.");
this.getLogger().info("Exec following command: git checkout -- " + StringUtils.join(filesToCheckout, " "));
ProcessBuilder processBuilder = new ProcessBuilder("git", "checkout", "--", StringUtils.join(filesToCheckout, " "))
.directory(git.getRepository().getDirectory().getParentFile()).inheritIO();
try {
Process p = processBuilder.start();
p.waitFor();
} catch (InterruptedException|IOException e) {
this.getLogger().error("Error while executing git command to checkout files: " + e);
return false;
}
//git.checkout().addPaths(filesToCheckout).call();
}
this.gitAdd(filesToAdd, git);
git.commit()
.setMessage("repairnator: add files created to push \n"+commitMsg)
.setCommitter(this.getCommitterIdent())
.setAuthor(this.getCommitterIdent()).call();
this.nbCommits++;
return true;
} else {
return false;
}
} catch (GitAPIException e) {
this.getLogger().error("Error while committing files created by Repairnator.", e);
return false;
}
}
public void initAllSubmodules(Git git) {
this.getLogger().info("Init git submodules.");
ProcessBuilder processBuilder = new ProcessBuilder("git", "submodule", "update", "--init", "--recursive")
.directory(git.getRepository().getDirectory().getParentFile()).inheritIO();
try {
Process p = processBuilder.start();
p.waitFor();
} catch (InterruptedException|IOException e) {
this.getLogger().error("Error while executing git command to get git submodules: " + e);
}
}
private String getLastKnowParent(GitHub gh, GHRepository ghRepo, Git git, String oldCommitSha, AbstractStep step) throws IOException {
showGitHubRateInformation(gh, step);
GHCommit commit = ghRepo.getCommit(oldCommitSha); // get the deleted
// commit from GH
List<String> commitParents = commit.getParentSHA1s();
if (commitParents.isEmpty()) {
step.addStepError("The following commit does not have any parent in GitHub: " + oldCommitSha
+ ". It cannot be resolved.");
return null;
}
if (commitParents.size() > 1) {
this.getLogger().debug("Step " + step.getName() + " - The commit has more than one parent : " + commit.getHtmlUrl());
}
String parent = commitParents.get(0);
try {
ObjectId commitObject = git.getRepository().resolve(parent);
git.getRepository().open(commitObject);
return parent;
} catch (MissingObjectException e) {
return getLastKnowParent(gh, ghRepo, git, parent, step);
}
}
private void showGitHubRateInformation(GitHub gh, AbstractStep step) throws IOException {
GHRateLimit rateLimit = gh.getRateLimit();
SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
this.getLogger().info("Step " + step.getName() + " - GitHub rate limit: Limit: " + rateLimit.limit +
" - Remaining: " + rateLimit.remaining + " - Reset hour: " + dateFormat.format(rateLimit.reset));
}
public boolean mergeTwoCommitsForPR(Git git, Build build, PullRequest prInformation, String repository, AbstractStep step, List<String> paths) {
try {
String remoteBranchPath = Utils.getCompleteGithubRepoUrl(prInformation.getOtherRepo().getFullName());
RemoteAddCommand remoteBranchCommand = git.remoteAdd();
remoteBranchCommand.setName("PR");
remoteBranchCommand.setUri(new URIish(remoteBranchPath));
remoteBranchCommand.call();
git.fetch().setRemote("PR").call();
String commitHeadSha = this.testCommitExistence(git, prInformation.getHead().getSHA1(), step, build);
String commitBaseSha = this.testCommitExistence(git, prInformation.getBase().getSHA1(), step, build);
if (commitHeadSha == null) {
step.addStepError("Commit head ref cannot be retrieved from the repository: "
+ prInformation.getHead().getSHA1() + ". Operation aborted.");
return false;
}
if (commitBaseSha == null) {
step.addStepError("Commit base ref cannot be retrieved from the repository: "
+ prInformation.getBase().getSHA1() + ". Operation aborted.");
return false;
}
this.getLogger().debug("Step " + step.getName() + " - Get the commit " + commitHeadSha + " for repo " + repository);
if (paths != null) {
this.gitResetPaths(commitHeadSha, paths, git.getRepository().getDirectory().getParentFile());
git.commit().setMessage("Undo changes on source code").setAuthor(this.getCommitterIdent()).setCommitter(this.getCommitterIdent()).call();
} else {
git.checkout().setName(commitHeadSha).call();
}
RevWalk revwalk = new RevWalk(git.getRepository());
RevCommit revCommitBase = revwalk.lookupCommit(git.getRepository().resolve(commitBaseSha));
this.getLogger().debug("Step " + step.getName() + " - Do the merge with the PR commit for repo " + repository);
MergeResult result = git.merge().include(revCommitBase).setFastForward(MergeCommand.FastForwardMode.NO_FF).call();
this.nbCommits++;
} catch (Exception e) {
step.addStepError(e.getMessage());
this.getLogger().error("Step " + step.getName() + " - Repository " + repository + " cannot be cloned.",e);
return false;
}
return true;
}
public String forkRepository(String repository, AbstractStep step) throws IOException {
GitHub gh = RepairnatorConfig.getInstance().getGithub();
showGitHubRateInformation(gh, step);
if (gh.getRateLimit().remaining > 10) {
GHRepository originalRepo = gh.getRepository(repository);
if (originalRepo != null) {
return originalRepo.fork().getUrl().toString();
}
}
return null;
}
public void computePatchStats(JobStatus jobStatus, Git git, RevCommit headRev, RevCommit commit) {
try {
ObjectReader reader = git.getRepository().newObjectReader();
CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
oldTreeIter.reset(reader, headRev.getTree());
CanonicalTreeParser newTreeIter = new CanonicalTreeParser();
newTreeIter.reset(reader, commit.getTree());
DiffFormatter diffFormatter = new DiffFormatter(DisabledOutputStream.INSTANCE);
diffFormatter.setRepository(git.getRepository());
diffFormatter.setContext(0);
List<DiffEntry> entries = diffFormatter.scan(newTreeIter, oldTreeIter);
int nbLineAdded = 0;
int nbLineDeleted = 0;
Set<String> changedFiles = new HashSet<>();
Set<String> addedFiles = new HashSet<>();
Set<String> deletedFiles = new HashSet<>();
for (DiffEntry entry : entries) {
String path;
if (entry.getChangeType() == DiffEntry.ChangeType.DELETE) {
path = entry.getOldPath();
} else {
path = entry.getNewPath();
}
if (!jobStatus.isCreatedFileToPush(path) && path.endsWith(".java")) {
if (entry.getChangeType() == DiffEntry.ChangeType.MODIFY ||
entry.getChangeType() == DiffEntry.ChangeType.RENAME) {
changedFiles.add(path);
} else if (entry.getChangeType() == DiffEntry.ChangeType.ADD ||
entry.getChangeType() == DiffEntry.ChangeType.COPY) {
addedFiles.add(path);
} else if (entry.getChangeType() == DiffEntry.ChangeType.DELETE) {
deletedFiles.add(path);
}
FileHeader fileHeader = diffFormatter.toFileHeader(entry);
List<? extends HunkHeader> hunks = fileHeader.getHunks();
for (HunkHeader hunk : hunks) {
EditList edits = hunk.toEditList();
for (Edit edit : edits) {
switch (edit.getType()) {
case INSERT:
nbLineAdded += edit.getLengthB();
break;
case DELETE:
nbLineDeleted += edit.getLengthA();
break;
case REPLACE:
int diff = edit.getLengthA() - edit.getLengthB();
if (diff > 0) {
nbLineAdded += edit.getLengthA();
nbLineDeleted += edit.getLengthB();
} else {
nbLineDeleted += edit.getLengthA();
nbLineAdded += edit.getLengthB();
}
break;
case EMPTY:
break;
}
}
}
}
}
PatchDiff patchDiff = jobStatus.getProperties().getPatchDiff();
patchDiff.getFiles().setNumberAdded(addedFiles.size());
patchDiff.getFiles().setNumberChanged(changedFiles.size());
patchDiff.getFiles().setNumberDeleted(deletedFiles.size());
patchDiff.getLines().setNumberAdded(nbLineAdded);
patchDiff.getLines().setNumberDeleted(nbLineDeleted);
} catch (IOException e) {
this.getLogger().error("Error while computing stat on the patch.", e);
}
}
public static int gitCreateNewBranchAndCheckoutIt(String path, String branchName) {
ProcessBuilder processBuilder = new ProcessBuilder("git", "checkout", "-b", branchName)
.directory(new File(path)).inheritIO();
try {
Process p = processBuilder.start();
return p.waitFor();
} catch (InterruptedException|IOException e) {
getLogger().error("Error while executing git command to create new branch and checkout it: " + e);
}
return -1;
}
public void gitAdd(List<String> files, Git git) {
for (String file : files) {
// add force is not supported by JGit...
ProcessBuilder processBuilder = new ProcessBuilder("git", "add", "-f", file)
.directory(git.getRepository().getDirectory().getParentFile()).inheritIO();
try {
Process p = processBuilder.start();
p.waitFor();
} catch (InterruptedException|IOException e) {
this.getLogger().error("Error while executing git command to add files: " + e);
}
}
}
public void gitResetPaths(String commit, List<String> paths, File gitDirectory) {
paths = this.removeDuplicatePaths(paths);
List<String> gitReset = new ArrayList<>();
gitReset.add("git");
gitReset.add("reset");
gitReset.add(commit);
gitReset.add("--");
for (String path : paths) {
gitReset.add(path);
}
this.executeGitCommand(gitReset.toArray(new String[0]), gitDirectory);
List<String> gitClean = new ArrayList<>();
gitClean.add("git");
gitClean.add("clean");
gitClean.add("-fd");
gitClean.add("--");
for (String path : paths) {
gitClean.add(path);
}
this.executeGitCommand(gitClean.toArray(new String[0]), gitDirectory);
String[] gitCheckout = {"git", "checkout", "--", "."};
this.executeGitCommand(gitCheckout, gitDirectory);
}
public void executeGitCommand(String[] gitCommand, File gitDirectory) {
this.getLogger().debug("Executing git command: " + StringUtils.join(gitCommand, " "));
ProcessBuilder processBuilder = new ProcessBuilder(gitCommand).directory(gitDirectory).inheritIO();
try {
Process process = processBuilder.start();
process.waitFor();
} catch (InterruptedException|IOException e) {
this.getLogger().error("Error while executing git command: " + e);
}
}
public List<String> removeDuplicatePaths(List<String> paths) {
List<String> newPaths = new ArrayList<>();
for (String path : paths) {
if (!newPaths.contains(path)) {
newPaths.add(path);
}
}
return newPaths;
}
}
```
|
```package fr.inria.spirals.repairnator.realtime;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Map;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.kohsuke.github.GHCommit;
import org.kohsuke.github.GHRepository;
import org.kohsuke.github.GitHub;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import fr.inria.spirals.repairnator.realtime.utils.PatchFilter;
import fr.inria.spirals.repairnator.realtime.utils.SequencerCollectorHunk;
import fr.inria.spirals.repairnator.realtime.utils.SequencerCollectorPatch;
@Ignore
public class TestSequencerCollector {
@Mock
GitHub github;
@Mock
GHCommit mockCommit;
@Mock
GHRepository mockRepo;
@Mock
PatchFilter filter;
@Spy
@InjectMocks
SequencerCollector collector;
@Before public void initMocks() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testDiffSaveAndPush() throws IOException{
ArrayList<SequencerCollectorPatch> emptyList = new ArrayList<>();
ArrayList<SequencerCollectorHunk> mockHunkList = new ArrayList<>(); mockHunkList.add(
new SequencerCollectorHunk(1, "file.java", "hunk1"));
//Mock external calls
Mockito.when(github.getRepository(Mockito.anyString())).thenReturn(mockRepo);
Mockito.when(mockRepo.getCommit(Mockito.anyString())).thenReturn(mockCommit);
//Mock hunk filter since mock commit is used
Mockito.when(filter.getCommitPatches(Mockito.any(GHCommit.class), Mockito.anyBoolean(), Mockito.anyInt(), Mockito.any(Map.class),mockRepo))
.thenReturn(emptyList);
Mockito.when(filter.getHunks(Mockito.any(ArrayList.class), Mockito.anyBoolean(), Mockito.anyInt())).thenReturn(mockHunkList);
//Mock save/commit/push methods
Mockito.doNothing().when(collector).saveFileDiff(Mockito.anyString(), Mockito.anyString());
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.realtime;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import fr.inria.spirals.repairnator.config.SequencerConfig;
import fr.inria.spirals.repairnator.realtime.utils.PatchFilter;
import fr.inria.spirals.repairnator.realtime.utils.SequencerCollectorHunk;
import fr.inria.spirals.repairnator.realtime.utils.SequencerCollectorPatch;
import org.kohsuke.github.*;
/**
* Filters and stores data for Sequencer training.
*/
public class SequencerCollector {
private final String diffsPath = SequencerConfig.getInstance().collectorPath;
private GitHub github;
private PatchFilter filter;
private boolean filterMultiFile;
private boolean filterMultiHunk;
private int hunkDistance;
private Set<String> done;
private int contextSize;
public SequencerCollector(int contextSize, boolean filterMultiFile, boolean filterMultiHunk, int hunkDistance) {
this.filterMultiFile = filterMultiFile;
this.filterMultiHunk = filterMultiHunk;
this.hunkDistance = hunkDistance;
this.done = new HashSet<>();
this.contextSize = contextSize;
filter = new PatchFilter();
}
public SequencerCollector(int contextSize, boolean filterMultiFile, boolean filterMultiHunk) {
this(contextSize, filterMultiFile, filterMultiHunk, 0);
}
public SequencerCollector(int contextSize) {
this(contextSize, false, false, 0);
}
public void handle(String repositorySlug, String sha) {
if (done.contains(sha)) {
return;
}
GHRepository repo;
GHCommit commit;
try {
repo = github.getRepository(repositorySlug);
commit = repo.getCommit(sha);
Map<String, String> allRawFiles = new HashMap<>();
ArrayList<SequencerCollectorPatch> patches = filter.getCommitPatches(commit, filterMultiFile, contextSize, allRawFiles, repo);
ArrayList<SequencerCollectorHunk> hunks = filter.getHunks(patches, filterMultiHunk, hunkDistance);
if (hunks.size() > 0) {
//create directory for file
String dirPath = diffsPath + "/" + repositorySlug.replace("/", "-") + "-" + sha;
File f = new File(dirPath);
f.mkdir();
// save hunks
hunks.forEach( (hunk) -> {
try {
String filename = hunk.getFile();
BufferedWriter writer;
writer = new BufferedWriter(
new FileWriter(dirPath + "/" + filename.substring(filename.lastIndexOf("/") + 1) + "-" + hunk.getLine()));
writer.append(Integer.toUnsignedLong(filename.hashCode()) + "\n");
writer.append(hunk.getContent());
writer.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
});
// save parent files
Set<String> neededFiles = hunks.stream().map(SequencerCollectorHunk::getFile).collect(Collectors.toSet());
Map<String, String> purgedRawFiles = neededFiles.stream()
.collect(Collectors.toMap(Function.identity(), allRawFiles::get));
purgedRawFiles.forEach((file, content) -> {
try {
BufferedWriter writer;
writer = new BufferedWriter(
new FileWriter(dirPath + "/" + Integer.toUnsignedLong(file.hashCode())));
writer.append(content);
writer.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
});
// save diff
saveFileDiff(repositorySlug, sha);
}
done.add(sha);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public void initialize() throws IOException {
initGithubConnection();
}
void initGithubConnection() throws IOException {
this.github = GitHub.connect(); // read credentials from ~/.github file
}
protected void saveFileDiff(String slug, String sha) throws IOException {
System.out.println("saving file...");
URL url = new URL("https", "github.com", "/" + slug + "/commit/" + sha + ".diff");
ReadableByteChannel readableByteChannel = Channels.newChannel(url.openStream());
File f = new File(diffsPath + "/" + slug.replace("/", "-") + "-" + sha + "/commit.diff");
f.createNewFile();
FileOutputStream fileOutputStream = new FileOutputStream(f, false);
fileOutputStream.getChannel().transferFrom(readableByteChannel, 0, Long.MAX_VALUE);
fileOutputStream.close();
}
}
```
|
```package fr.inria.spirals.repairnator.scanner;
import fr.inria.jtravis.entities.Build;
import fr.inria.jtravis.entities.StateType;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.states.LauncherMode;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.util.Date;
import java.util.Optional;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class ProjectScannerTest {
@Test
@Ignore //TODO: Find a valid JTravis project
public void testBuildWithoutFailingTestAndRepairMode() {
long buildId = 220482792; // repairnator/failingProject build without failing tests
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setJTravisEndpoint("https://api.travis-ci.com");
config.setLauncherMode(LauncherMode.REPAIR);
Optional<Build> buildOptional = config.getJTravis().build().fromId(buildId);
assertTrue(buildOptional.isPresent());
Build build = buildOptional.get();
ProjectScanner projectScanner = new ProjectScanner(new Date(), new Date(), "test");
boolean isOKForRepair = projectScanner.testBuild(build);
assertFalse(isOKForRepair);
}
@Test
@Ignore //TODO: Find a valid JTravis project
public void testBuildWithFailingTestAndRepairMode() {
long buildId = 220926535; // repairnator/failingProject build with failing tests
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setJTravisEndpoint("https://api.travis-ci.com");
config.setLauncherMode(LauncherMode.REPAIR);
Optional<Build> buildOptional = config.getJTravis().build().fromId(buildId);
assertTrue(buildOptional.isPresent());
Build build = buildOptional.get();
ProjectScanner projectScanner = new ProjectScanner(new Date(), new Date(), "test");
boolean isOKForRepair = projectScanner.testBuild(build);
assertTrue(isOKForRepair);
}
@Test
@Ignore //TODO: Find a valid JTravis project
public void testBuildWithFailingAndBearsMode() {
long buildId = 220926535; // repairnator/failingProject build with failing tests
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setLauncherMode(LauncherMode.BEARS);
config.setJTravisEndpoint("https://api.travis-ci.com");
Optional<Build> buildOptional = config.getJTravis().build().fromId(buildId);
assertTrue(buildOptional.isPresent());
Build build = buildOptional.get();
ProjectScanner projectScanner = new ProjectScanner(new Date(), new Date(), "test");
boolean isOKForBears = projectScanner.testBuild(build);
assertFalse(isOKForBears);
}
@Test
@Ignore //TODO: Find a valid JTravis project
public void testBuildWithPassingAndBearsMode() {
long buildId = 220482792; // repairnator/failingProject build without failing tests
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setLauncherMode(LauncherMode.BEARS);
config.setJTravisEndpoint("https://api.travis-ci.com");
Optional<Build> buildOptional = config.getJTravis().build().fromId(buildId);
assertTrue(buildOptional.isPresent());
Build build = buildOptional.get();
ProjectScanner projectScanner = new ProjectScanner(new Date(), new Date(), "test");
boolean isOKForBears = projectScanner.testBuild(build);
assertTrue(isOKForBears);
}
@Test
@Ignore // because too slow, because it iterates over all builds of Spoon which is too much and a little worse every day
public void testGetBuildToBeInspectedWithFailingFromPR() {
long buildId = 364156914; // inria/spoon failing from PR with failing tests
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setLauncherMode(LauncherMode.REPAIR);
Optional<Build> buildOptional = config.getJTravis().build().fromId(buildId);
assertTrue(buildOptional.isPresent());
Build build = buildOptional.get();
assertEquals(StateType.FAILED, build.getState());
ProjectScanner projectScanner = new ProjectScanner(new Date(), new Date(), "test");
BuildToBeInspected expectedBuildToBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "test");
BuildToBeInspected obtainedBTB = projectScanner.getBuildToBeInspected(build);
assertEquals(expectedBuildToBeInspected, obtainedBTB);
}
@Test
@Ignore // because too slow, because it iterates over all builds of Spoon which is too much and a little worse every day
public void testGetBuildToBeInspectedWithPassingWithPreviousFailingFromPR() {
long buildIdFailing = 324127095; // inria/spoon
long buildIdNextPassing = 324525330;
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setLauncherMode(LauncherMode.BEARS);
Optional<Build> buildOptional = config.getJTravis().build().fromId(buildIdFailing);
assertTrue(buildOptional.isPresent());
Build buildFailing = buildOptional.get();
assertEquals(StateType.FAILED, buildFailing.getState());
buildOptional = config.getJTravis().build().fromId(buildIdNextPassing);
assertTrue(buildOptional.isPresent());
Build buildNextPassing = buildOptional.get();
assertEquals(StateType.PASSED, buildNextPassing.getState());
ProjectScanner projectScanner = new ProjectScanner(new Date(), new Date(), "test");
BuildToBeInspected expectedBuildToBeInspected = new BuildToBeInspected(buildFailing, buildNextPassing, ScannedBuildStatus.FAILING_AND_PASSING, "test");
BuildToBeInspected obtainedBTB = projectScanner.getBuildToBeInspected(buildNextPassing);
assertEquals(expectedBuildToBeInspected.getBuggyBuild().getId(), obtainedBTB.getBuggyBuild().getId());
assertEquals(expectedBuildToBeInspected.getPatchedBuild().getId(), obtainedBTB.getPatchedBuild().getId());
}
@Test
@Ignore // because too slow, because it iterates over all builds of Spoon which is too much and a little worse every day
public void testGetBuildToBeInspectedWithPassingWithPreviousPassingFromPR() {
long buildIdPassing = 210093951; // inria/spoon
long buildIdNextPassing = 211479830;
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setLauncherMode(LauncherMode.BEARS);
Optional<Build> buildOptional = config.getJTravis().build().fromId(buildIdPassing);
assertTrue(buildOptional.isPresent());
Build buildPassing = buildOptional.get();
assertEquals(StateType.PASSED, buildPassing.getState());
buildOptional = config.getJTravis().build().fromId(buildIdNextPassing);
assertTrue(buildOptional.isPresent());
Build buildNextPassing = buildOptional.get();
assertEquals(StateType.PASSED, buildNextPassing.getState());
ProjectScanner projectScanner = new ProjectScanner(new Date(), new Date(), "test");
BuildToBeInspected expectedBuildToBeInspected = new BuildToBeInspected(buildPassing, buildNextPassing, ScannedBuildStatus.PASSING_AND_PASSING_WITH_TEST_CHANGES, "test");
BuildToBeInspected obtainedBTB = projectScanner.getBuildToBeInspected(buildNextPassing);
assertEquals(expectedBuildToBeInspected.getBuggyBuild().getId(), obtainedBTB.getBuggyBuild().getId());
}
/*
The pair of builds is failing and passing.
This pair should not be selected by the scanner, i.e. a BuildToBeInspected should not be created,
because the failing build did not fail in Travis due to test failure.
*/
@Test
@Ignore // because too slow, because it iterates over all builds of Spoon which is too much and a little worse every day
public void testGetBuildToBeInspectedWithPassingBuildWithPreviousFailingBuildBears() {
long buildIdFailing = 230022061; // inria/spoon
long buildIdNextPassing = 230049446;
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setLauncherMode(LauncherMode.BEARS);
Optional<Build> buildOptional = config.getJTravis().build().fromId(buildIdFailing);
assertTrue(buildOptional.isPresent());
Build buildFailing = buildOptional.get();
assertEquals(StateType.FAILED, buildFailing.getState());
buildOptional = config.getJTravis().build().fromId(buildIdNextPassing);
assertTrue(buildOptional.isPresent());
Build buildNextPassing = buildOptional.get();
assertEquals(StateType.PASSED, buildNextPassing.getState());
ProjectScanner projectScanner = new ProjectScanner(new Date(), new Date(), "test");
BuildToBeInspected obtainedBTB = projectScanner.getBuildToBeInspected(buildNextPassing);
assertEquals(null, obtainedBTB);
}
/*
The pair of builds is passing and passing.
This pair should not be selected by the scanner, i.e. a BuildToBeInspected should not be created,
because there is no java file changed between the two builds (there is only test file).
*/
@Test
@Ignore // because too slow, because it iterates over all builds of Spoon which is too much and a little worse every day
public void testGetBuildToBeInspectedWithPassingBuildWithPreviousPassingBuildBears() {
long buildIdPassing = 323802157; // inria/spoon
long buildIdNextPassing = 323823511;
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setLauncherMode(LauncherMode.BEARS);
Optional<Build> buildOptional = config.getJTravis().build().fromId(buildIdPassing);
assertTrue(buildOptional.isPresent());
Build buildPassing = buildOptional.get();
assertEquals(StateType.PASSED, buildPassing.getState());
buildOptional = config.getJTravis().build().fromId(buildIdNextPassing);
assertTrue(buildOptional.isPresent());
Build buildNextPassing = buildOptional.get();
assertEquals(StateType.PASSED, buildNextPassing.getState());
ProjectScanner projectScanner = new ProjectScanner(new Date(), new Date(), "test");
BuildToBeInspected obtainedBTB = projectScanner.getBuildToBeInspected(buildNextPassing);
assertEquals(null, obtainedBTB);
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.scanner;
import fr.inria.jtravis.JTravis;
import fr.inria.jtravis.entities.*;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.DateUtils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.states.BearsMode;
import fr.inria.spirals.repairnator.states.LauncherMode;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.kohsuke.github.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* This class aims to provide utility methods to scan the projects and get
* failing builds
*
* @author Simon Urli
*/
public class ProjectScanner {
private final Logger logger = LoggerFactory.getLogger(ProjectScanner.class);
private int totalRepoNumber;
private int totalRepoUsingTravis;
private int totalScannedBuilds;
private int totalPRBuilds;
private int totalBuildInJava;
private int totalJavaPassingBuilds;
private int totalBuildInJavaFailing;
private int totalBuildInJavaFailingWithFailingTests;
private int totalNumberOfFailingAndPassingBuildPairs;
private int totalNumberOfPassingAndPassingBuildPairs;
private Collection<String> slugs;
private Collection<Repository> repositories;
private Date lookFromDate;
private Date lookToDate;
private String runId;
private Date scannerRunningBeginDate;
private Date scannerRunningEndDate;
private JTravis jTravis;
public ProjectScanner(Date lookFromDate, Date lookToDate, String runId) {
this.lookFromDate = lookFromDate;
this.lookToDate = lookToDate;
this.slugs = new HashSet<String>();
this.repositories = new HashSet<Repository>();
this.runId = runId;
this.jTravis = RepairnatorConfig.getInstance().getJTravis();
this.logger.info("Look from " + DateUtils.formatCompleteDate(this.lookFromDate) + " to " + DateUtils.formatCompleteDate(this.lookToDate));
}
public String getRunId() {
return runId;
}
public int getTotalRepoNumber() {
return totalRepoNumber;
}
public int getTotalRepoUsingTravis() {
return totalRepoUsingTravis;
}
public int getTotalScannedBuilds() {
return totalScannedBuilds;
}
public int getTotalPRBuilds() {
return totalPRBuilds;
}
public int getTotalBuildInJava() {
return totalBuildInJava;
}
public int getTotalJavaPassingBuilds() {
return totalJavaPassingBuilds;
}
public int getTotalBuildInJavaFailing() {
return totalBuildInJavaFailing;
}
public int getTotalBuildInJavaFailingWithFailingTests() {
return totalBuildInJavaFailingWithFailingTests;
}
public int getTotalNumberOfFailingAndPassingBuildPairs() {
return totalNumberOfFailingAndPassingBuildPairs;
}
public int getTotalNumberOfPassingAndPassingBuildPairs() {
return totalNumberOfPassingAndPassingBuildPairs;
}
public Date getLookFromDate() {
return lookFromDate;
}
public Date getLookToDate() {
return lookToDate;
}
public Date getScannerRunningBeginDate() {
return scannerRunningBeginDate;
}
public Date getScannerRunningEndDate() {
return scannerRunningEndDate;
}
public String getScannerDuration() {
if (this.scannerRunningBeginDate == null || this.scannerRunningEndDate == null) {
return "";
}
double diffInMilliseconds = this.scannerRunningEndDate.getTime() - this.scannerRunningBeginDate.getTime();
int minutes = (int) (diffInMilliseconds / 1000) / 60;
int seconds = (int) (diffInMilliseconds / 1000) % 60;
int hours = minutes / 60;
minutes = minutes % 60;
return hours + ":" + minutes + ":" + seconds;
}
private List<String> getFileContent(String path) throws IOException {
List<String> result = new ArrayList<String>();
File file = new File(path);
BufferedReader reader = new BufferedReader(new FileReader(file));
while (reader.ready()) {
result.add(reader.readLine().trim());
}
return result;
}
/**
* Take a filepath as input containing a list of projects to scan. Check
* last build of each project. And finally returns the list of failing
* builds.
*
* @param path
* A path to a file formatted to contain a slug name of project
* per line (ex: INRIA/spoon)
* @return a list of failing builds
* @throws IOException
*/
public Map<ScannedBuildStatus, List<BuildToBeInspected>> getListOfBuildsToBeInspectedFromProjects(String path) throws IOException {
this.scannerRunningBeginDate = new Date();
List<String> slugs = getFileContent(path);
this.totalRepoNumber = slugs.size();
this.logger.info("# Repositories found: "+this.totalRepoNumber);
List<Repository> repos = getListOfValidRepository(slugs);
Map<ScannedBuildStatus, List<BuildToBeInspected>> builds = getListOfBuildsFromRepo(repos);
this.scannerRunningEndDate = new Date();
return builds;
}
public Map<ScannedBuildStatus, List<BuildToBeInspected>> getBuildsGivenSlug (String slug) {
ArrayList<String> listSlug = new ArrayList<String>();
listSlug.add(slug);
List<Repository> repo = getListOfValidRepository(listSlug);
return getListOfBuildsFromRepo(repo);
}
private List<Repository> getListOfValidRepository(List<String> allSlugs) {
List<Repository> result = new ArrayList<Repository>();
this.logger.debug("---------------------------------------------------------------");
this.logger.debug("Checking the "+this.totalRepoNumber+" repositories.");
this.logger.debug("---------------------------------------------------------------");
for (String slug : allSlugs) {
this.logger.debug("Get repo " + slug);
Optional<Repository> repositoryOptional = this.jTravis.repository().fromSlug(slug);
if (repositoryOptional.isPresent()) {
Repository repo = repositoryOptional.get();
Optional<Build> lastBuild = repo.getLastBuild();
if (lastBuild.isPresent()) {
result.add(repo);
} else {
this.logger.info("It seems that the repo " + slug + " does not have any Travis build.");
}
} else {
this.logger.warn("Can't examine repo : " + slug);
}
}
this.totalRepoUsingTravis = result.size();
this.logger.info("# Repositories using Travis: "+this.totalRepoUsingTravis);
return result;
}
private Map<ScannedBuildStatus, List<BuildToBeInspected>> getListOfBuildsFromRepo(List<Repository> repos) {
Map<ScannedBuildStatus, List<BuildToBeInspected>> results = new HashMap<>();
for (ScannedBuildStatus status : ScannedBuildStatus.values()) {
results.put(status, new ArrayList<>());
}
this.logger.debug("---------------------------------------------------------------");
this.logger.debug("Scanning builds.");
this.logger.debug("---------------------------------------------------------------");
for (Repository repo : repos) {
Optional<List<Build>> builds = this.jTravis.build().betweenDates(repo.getSlug(), this.lookFromDate, this.lookToDate);
if (builds.isPresent()) {
List<Build> repoBuilds = builds.get();
for (Build build : repoBuilds) {
this.totalScannedBuilds++;
BuildToBeInspected buildToBeInspected = getBuildToBeInspected(build);
if (buildToBeInspected != null) {
results.get(buildToBeInspected.getStatus()).add(buildToBeInspected);
}
}
}
}
return results;
}
/**
* Find a candidate build.
* warning: this method is slow, because method `getBeforeOrAfter()` iterates over all builds of the repo of `build`
* which can be very slow for big repos
*/
public BuildToBeInspected getBuildToBeInspected(Build build) {
if (testBuild(build)) {
if (RepairnatorConfig.getInstance().getLauncherMode() == LauncherMode.REPAIR) {
this.logger.debug("Build "+build.getId()+" is interesting to be inspected.");
return new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, this.runId);
} else {
this.logger.debug("Build "+build.getId()+" seems interesting to be inspected, thus get its previous build...");
Optional<Build> optionalBeforeBuild = this.jTravis.build().getBefore(build, true);
if (optionalBeforeBuild.isPresent()) {
Build previousBuild = optionalBeforeBuild.get();
// FIXME: the next line can be removed once the issue https://github.com/Spirals-Team/jtravis/issues/21 is fixed in jtravis.
previousBuild = jTravis.build().getEntityFromUri(Build.class, previousBuild.getUri()).get();
this.logger.debug("Previous build: " + previousBuild.getId());
BearsMode mode = RepairnatorConfig.getInstance().getBearsMode();
if ((mode == BearsMode.BOTH || mode == BearsMode.FAILING_PASSING) && previousBuild.getState() == StateType.FAILED && thereIsDiffOnJavaFile(build, previousBuild) && isFailedBuildFailingByTestFailure(previousBuild)) {
this.totalNumberOfFailingAndPassingBuildPairs++;
this.logger.debug("The pair "+previousBuild.getId()+" ["+previousBuild.getState()+"], "+build.getId()+" ["+build.getState()+"] is interesting to be inspected.");
return new BuildToBeInspected(previousBuild, build, ScannedBuildStatus.FAILING_AND_PASSING, this.runId);
} else {
if ((mode == BearsMode.BOTH || mode == BearsMode.PASSING_PASSING) && previousBuild.getState() == StateType.PASSED && thereIsDiffOnJavaFile(build, previousBuild) && thereIsDiffOnTests(build, previousBuild)) {
this.totalNumberOfPassingAndPassingBuildPairs++;
this.logger.debug("The pair "+previousBuild.getId()+" ["+previousBuild.getState()+"], "+build.getId()+" ["+build.getState()+"] is interesting to be inspected.");
return new BuildToBeInspected(previousBuild, build, ScannedBuildStatus.PASSING_AND_PASSING_WITH_TEST_CHANGES, this.runId);
} else {
this.logger.debug("The pair "+previousBuild.getId()+" ["+previousBuild.getState()+"], "+build.getId()+" ["+build.getState()+"] is NOT interesting to be inspected.");
}
}
} else {
this.logger.debug("The previous build from "+build.getId()+" was not retrieved.");
}
}
} else {
this.logger.debug("Build "+build.getId()+" is not interesting to be inspected.");
}
return null;
}
protected boolean testBuild(Build build) {
if (build.isPullRequest()) {
this.totalPRBuilds++;
}
Repository repo = build.getRepository();
String language = build.getLanguage();
if ("java".equals(language)) {
this.totalBuildInJava++;
this.logger.debug("Repo " + repo.getSlug() + " with java language - build " + build.getId() + " - Status : "
+ build.getState().name());
if (build.getState() == StateType.FAILED) {
this.totalBuildInJavaFailing++;
if (isFailedBuildFailingByTestFailure(build)) {
this.totalBuildInJavaFailingWithFailingTests++;
if (RepairnatorConfig.getInstance().getLauncherMode() == LauncherMode.REPAIR) {
this.slugs.add(repo.getSlug());
this.repositories.add(repo);
return true;
} else {
return false;
}
}
} else if (build.getState() == StateType.PASSED) {
this.totalJavaPassingBuilds++;
if (RepairnatorConfig.getInstance().getLauncherMode() == LauncherMode.BEARS) {
for (Job job : build.getJobs()) {
RepairnatorConfig.getInstance().getJTravis().refresh(job);
if (job.getState() == StateType.PASSED) {
Optional<Log> optionalLog = job.getLog();
if (optionalLog.isPresent()) {
Log jobLog = optionalLog.get();
if (jobLog.getBuildTool() == BuildTool.MAVEN) {
this.slugs.add(repo.getSlug());
this.repositories.add(repo);
return true;
} else {
logger.debug("Maven is not used in the build " + build.getId());
}
}
}
}
}
}
} else {
this.logger.warn("Examine repo " + repo.getSlug() + " Careful the following build " + build.getId()
+ " is not in java but language: " + language);
}
return false;
}
private boolean isFailedBuildFailingByTestFailure(Build build) {
for (Job job : build.getJobs()) {
RepairnatorConfig.getInstance().getJTravis().refresh(job);
if (job.getState() == StateType.FAILED) {
Optional<Log> optionalLog = job.getLog();
if (optionalLog.isPresent()) {
Log jobLog = optionalLog.get();
if (jobLog.getBuildTool() == BuildTool.MAVEN) {
TestsInformation testInfo = jobLog.getTestsInformation();
// testInfo can be null if the build tool is unknown
if (testInfo != null && (testInfo.getFailing() > 0 || testInfo.getErrored() > 0)) {
return true;
} else {
logger.debug("No failing or erroring test found in build " + build.getId());
}
} else {
logger.debug("Maven is not used in the build " + build.getId());
}
} else {
logger.error("Error while getting a job log: (jobId: " + job.getId() + ")");
}
}
}
return false;
}
private boolean thereIsDiffOnJavaFile(Build build, Build previousBuild) {
GHCompare compare = this.getCompare(build, previousBuild);
if (compare != null) {
GHCommit.File[] modifiedFiles = compare.getFiles();
for (GHCommit.File file : modifiedFiles) {
if (file.getFileName().endsWith(".java") && !file.getFileName().toLowerCase().contains("/test/")) {
this.logger.debug("First java file found: " + file.getFileName());
return true;
}
}
}
return false;
}
private boolean thereIsDiffOnTests(Build build, Build previousBuild) {
GHCompare compare = this.getCompare(build, previousBuild);
if (compare != null) {
GHCommit.File[] modifiedFiles = compare.getFiles();
for (GHCommit.File file : modifiedFiles) {
if (file.getFileName().toLowerCase().contains("/test/") && file.getFileName().endsWith(".java")) {
this.logger.debug("First probable test file found: " + file.getFileName());
return true;
}
}
}
return false;
}
private GHCompare getCompare(Build build, Build previousBuild) {
try {
GitHub gh = GitHubBuilder.fromEnvironment().build();
GHRateLimit rateLimit = gh.getRateLimit();
SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
this.logger.debug("GitHub rate limit: Limit: " + rateLimit.limit + " - Remaining: " + rateLimit.remaining + " - Reset hour: " + dateFormat.format(rateLimit.reset));
if (rateLimit.remaining > 2) {
GHRepository ghRepo = gh.getRepository(build.getRepository().getSlug());
GHCommit buildCommit = ghRepo.getCommit(build.getCommit().getSha());
GHCommit previousBuildCommit = ghRepo.getCommit(previousBuild.getCommit().getSha());
GHCompare compare = ghRepo.getCompare(previousBuildCommit, buildCommit);
return compare;
} else {
this.logger.warn("You reached your rate limit for GitHub. You have to wait until " + dateFormat.format(rateLimit.reset) + " to get data. PRInformation will be null for build "+build.getId()+".");
}
} catch (IOException e) {
this.logger.warn("Error while getting commit from GitHub: " + e);
}
return null;
}
}
```
|
```package fr.inria.spirals.repairnator.realtime;
import fr.inria.spirals.repairnator.InputBuild;
import fr.inria.spirals.repairnator.realtime.githubapi.commits.models.SelectedCommit;
import org.apache.commons.io.FileUtils;
import org.junit.Test;
import static junit.framework.TestCase.*;
import static org.mockito.Mockito.*;
import org.mockito.internal.util.reflection.Whitebox;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class TestGithubScanner {
@Test
public void testBuildSubmission(){
DockerPipelineRunner runner = mock(DockerPipelineRunner.class);
GithubScanner scanner = new GithubScanner();
Whitebox.setInternalState(scanner, "runner", runner);
boolean isGithubActionsFailed = false;
String commitId = "fda5d6161a5602a76e810209491d04cf91f4803b";
String repoName = "repairnator/failingProject";
SelectedCommit commit = new SelectedCommit(isGithubActionsFailed, commitId, repoName);
scanner.process(commit);
verify(runner, times(1)).submitBuild(any(InputBuild.class));
}
@Test
public void testFetchingAll() throws Exception {
// repo https://github.com/castor-software/depclean/commits/master
Set<String> repos = new HashSet<String>(FileUtils.readLines(new File(getClass()
.getResource("/GithubScannerTest_repos.txt").getFile()), "UTF-8"));
GithubScanner scanner = new GithubScanner();
scanner.setup();
List<SelectedCommit> commits =
scanner.fetch(new SimpleDateFormat("dd/MM/yyyy").parse("14/12/2022").getTime(),
new SimpleDateFormat("dd/MM/yyyy").parse("10/04/2023").getTime(),
GithubScanner.FetchMode.ALL, repos);
assertTrue(commits.stream().anyMatch(x -> x.getCommitId().equals("462bca1472db3198c2e47aff072126209f796bce")));
assertTrue(commits.stream().anyMatch(x -> x.getCommitId().equals("f8a2607178ed48e5843768c3cbc8e60406d63a66")));
assertTrue(commits.stream().anyMatch(x -> x.getCommitId().equals("e2e8afe4a06c437c5eb4a3edc20c3152450ac702")));
assertTrue(commits.stream().anyMatch(x -> x.getCommitId().equals("5180598adbdff8f9d3c53c6e647290614bf752b9")));
}
@Test
public void testFetchingFailed() throws Exception {
// repo https://github.com/castor-software/depclean/commits/master
// for future mantainer make sure the failing commit is not related to a codecov failure
Set<String> repos = new HashSet<String>(FileUtils.readLines(new File(getClass()
.getResource("/GithubScannerTest_repos.txt").getFile()), "UTF-8"));
GithubScanner scanner = new GithubScanner();
scanner.setup();
List<SelectedCommit> commits =
scanner.fetch(new SimpleDateFormat("dd/MM/yyyy").parse("14/06/2021").getTime(),
new SimpleDateFormat("dd/MM/yyyy").parse("10/09/2022").getTime(),
GithubScanner.FetchMode.FAILED, repos);
assertFalse(commits.stream().anyMatch(x -> x.getCommitId().equals("063572c0b7747498940a06c240a71193ec8314ee")));
assertTrue(commits.stream().anyMatch(x -> x.getCommitId().equals("332672710a7a90c5c51a09064f0917435bd5a6ec")));
}
@Test
public void testFetchingPassing() throws Exception {
// repo https://github.com/castor-software/depclean/commits/master
Set<String> repos = new HashSet<String>(FileUtils.readLines(new File(getClass()
.getResource("/GithubScannerTest_repos.txt").getFile()), "UTF-8"));
GithubScanner scanner = new GithubScanner();
scanner.setup();
List<SelectedCommit> commits =
scanner.fetch(new SimpleDateFormat("dd/MM/yyyy").parse("14/06/2021").getTime(),
new SimpleDateFormat("dd/MM/yyyy").parse("10/09/2021").getTime(),
GithubScanner.FetchMode.PASSING, repos);
assertTrue(commits.stream().anyMatch(x -> x.getCommitId().equals("08cddb1c57eebb3ccd320061b75fd26cb09fc1fd")));
assertFalse(commits.stream().anyMatch(x -> x.getCommitId().equals("332672710a7a90c5c51a09064f0917435bd5a6ec")));
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.realtime;
import fr.inria.spirals.repairnator.GithubInputBuild;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.step.feedback.sobo.SoboAdapter;
import fr.inria.spirals.repairnator.realtime.githubapi.commits.GithubAPICommitAdapter;
import fr.inria.spirals.repairnator.realtime.githubapi.commits.models.SelectedCommit;
import fr.inria.spirals.repairnator.realtime.utils.SOBOUtils;
import fr.inria.spirals.repairnator.states.LauncherMode;
import org.apache.commons.io.FileUtils;
import org.kohsuke.github.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import static fr.inria.spirals.repairnator.realtime.Constants.SEQUENCER_NAME;
import static fr.inria.spirals.repairnator.realtime.Constants.SORALD_NAME;
public class GithubScanner {
private final static Logger logger = LoggerFactory.getLogger(GithubScanner.class);
static long scanIntervalDelay = 60 * 60 * 1000; // 1 hour
static long frequency = 60 * 60 * 1000; // 1 hour
long lastFetchedTime = -1L;
long scanStartTime = 0;
PipelineRunner runner;
public GithubScanner(){
setup();
}
public static void main(String[] args) throws IOException {
GithubScanner scanner = new GithubScanner();
String reposPath = System.getenv("REPOS_PATH");
if (reposPath != null) {
// a list of repos to be monitored online is provided
Set<String> repos = new HashSet<>(FileUtils.readLines(new File(reposPath), "UTF-8"));
if(System.getenv("launcherMode").equals("FEEDBACK") && System.getenv("command").equals("true") ){
frequency=Long.parseLong(getEnvOrDefault("commandFrequency","10000"));
scanIntervalDelay=Long.parseLong(getEnvOrDefault("commandFrequency","10000"));
scanner.fetchAndProcessCommandsPeriodically(repos);
}else{
frequency=Long.parseLong(getEnvOrDefault("commandFrequency","30000"));
scanIntervalDelay=Long.parseLong(getEnvOrDefault("commandFrequency","30000"));
FetchMode fetchMode = parseFetchMode();
// here is how we send the line to check the repos
scanner.fetchAndProcessCommitsPeriodically(repos, fetchMode);}
} else {
List<SelectedCommit> selectedCommits = readSelectedCommitsFromFile();
scanner.processSelectedCommits(selectedCommits);
}
}
private void fetchAndProcessCommandsPeriodically(Set<String> repos) {
while (true) {
try {
List<GHIssueComment> CommandIssues = fetchCommands( repos);
logger.info("fetched commands: ");
for (GHIssueComment commandIssue: CommandIssues) {
System.out.println(commandIssue.getBody());
}
TimeUnit.MILLISECONDS.sleep(Integer.parseInt(getEnvOrDefault("commandFrequency","10000")));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
private List<GHIssueComment> fetchCommands(Set<String> repos) throws IOException {
List<GHIssueComment> issueComments = new ArrayList<>();
int i=0;
for (String repo : repos) {
String user = SOBOUtils.getUserName(repo);
String task = SOBOUtils.getTask(repo);
GHIssue issue= SoboAdapter.getInstance("").getCommandIssue(repo, user, logger);
if (issue!= null) {
try {
GHIssueComment lastComment= SoboAdapter.getInstance("").getLastCommand(issue.getComments());
logger.info(i+" "+issue.getRepository().getName());
if (lastComment!=null){
SoboAdapter.getInstance("").analyzeCommand(user,repo,task,logger,lastComment,issue);
}
}catch (Exception e) {
logger.info(i+" "+"Unable to get the last Comment - "+issue.getRepository().getFullName());
}
}
i++;
}
return issueComments;
}
private void fetchAndProcessCommitsPeriodically(Set<String> repos, FetchMode fetchMode) {
while (true) {
try {
List<SelectedCommit> selectedCommits = fetch(fetchMode, repos);
logger.info("fetched commits: ");
selectedCommits.forEach(c -> System.out.println(c.getRepoName() + " " + c.getCommitId()
+ " " + c.getGithubActionsFailed()));
processSelectedCommits(selectedCommits);
TimeUnit.MILLISECONDS.sleep((Integer.parseInt(getEnvOrDefault("commandFrequency","60000"))));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
//TODO: CREATE THE FEEDBACK PATH TO CONNECT THE ELEMENTS
private void processSelectedCommits(List<SelectedCommit> selectedCommits) {
for (int i = selectedCommits.size()-1; i >-1 ; i--) {
SelectedCommit commit = selectedCommits.get(i);
logger.info("Commit being submitted to the repair pipeline: " + commit.getCommitUrl() + " "
+ commit.getCommitId() + "; " + (i + 1) + " out of " + selectedCommits.size());
process(commit);
}
}
private static List<SelectedCommit> readSelectedCommitsFromFile() throws IOException {
String selectedCommitsPath = System.getenv("SELECTED_COMMITS_PATH");
return FileUtils.readLines(new File(selectedCommitsPath), "UTF-8").stream()
.map(c -> new SelectedCommit(false, c.split(",")[1], c.split(",")[0]))
.collect(Collectors.toList());
}
// If you want to monitor... certain commits in a period of time you used this,
// in SOBO we will not have the list of commits, we will find for the new commits
public List<SelectedCommit> fetch(FetchMode fetchMode, Set<String> repos) throws Exception {
long endTime = System.currentTimeMillis() - scanIntervalDelay;
long startTime = lastFetchedTime < 0 ? scanStartTime : lastFetchedTime;
List<SelectedCommit> commits = fetch(startTime, endTime, fetchMode, repos);
lastFetchedTime = endTime;
return commits;
}
public void setup() {
Set<String> repairTools = new HashSet<>();
Set<String> feedbackTools = new HashSet<>();
String launcherMode=getEnvOrDefault("launcherMode", "REPAIR");
RepairnatorConfig.getInstance().setGithubToken(System.getenv("GITHUB_OAUTH"));
if (launcherMode.equals("FEEDBACK")){
String feedbackTool = getEnvOrDefault("FEEDBACK_TOOL", "SoboBot");
feedbackTools.add(feedbackTool);
RepairnatorConfig.getInstance().setLauncherMode(LauncherMode.FEEDBACK);
RepairnatorConfig.getInstance().setFeedbackTools(feedbackTools);
runner = new SimplePipelineRunner();
if (!System.getenv("command").equals("true") ) runner.initRunner();
}else{
String repairTool = getEnvOrDefault("REPAIR_TOOL", SEQUENCER_NAME);
repairTools.add(repairTool);
RepairnatorConfig.getInstance().setRepairTools(repairTools);
if (repairTool.equals(SORALD_NAME)) {
runner = new SimplePipelineRunner();
} else if (repairTool.equals(SEQUENCER_NAME)) {
RepairnatorConfig.getInstance().setLauncherMode(LauncherMode.SEQUENCER_REPAIR);
RepairnatorConfig.getInstance().setNbThreads(16);
RepairnatorConfig.getInstance().setPipelineMode(RepairnatorConfig.PIPELINE_MODE.DOCKER.name());
RepairnatorConfig.getInstance().setDockerImageName(System.getenv("DOCKER_IMAGE_NAME"));
runner = new DockerPipelineRunner();
}
runner.initRunner();
}
try {
if (System.getenv().containsKey("SCAN_START_TIME"))
scanStartTime = new SimpleDateFormat("MM/dd/yyyy")
.parse(System.getenv("SCAN_START_TIME")).getTime();
} catch (ParseException e) {
e.printStackTrace();
}
}
public List<SelectedCommit> fetch(long startTime, long endTime, FetchMode fetchMode, Set<String> repos)
throws Exception {
return GithubAPICommitAdapter.getInstance().getSelectedCommits(startTime, endTime, fetchMode, repos);
}
public void process(SelectedCommit commit) {
String sha = commit.getCommitId();
if(System.getenv("ENTERPRISE")!= null){
String API_URL = System.getenv("ENTERPRISE"); //example https://gits-15.sys.kth.se/
String url = API_URL + commit.getRepoName();
runner.submitBuild(new GithubInputBuild(url, null, sha));
}else{
String url = "https://github.com/" + commit.getRepoName();
runner.submitBuild(new GithubInputBuild(url, null, sha));}
}
private static String getEnvOrDefault(String name, String dfault) {
String env = System.getenv(name);
if (env == null || env.equals(""))
return dfault;
return env;
}
private static FetchMode parseFetchMode() {
String value = getEnvOrDefault("FETCH_MODE", "failed");
switch (value) {
case "all":
return FetchMode.ALL;
case "passing":
return FetchMode.PASSING;
case "failed":
default:
return FetchMode.FAILED;
}
}
public enum FetchMode {
FAILED, ALL, PASSING
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.repair;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.inspectors.RepairPatch;
import fr.inria.spirals.repairnator.process.step.BuildProject;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.TestProject;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.step.gatherinfo.BuildShouldFail;
import fr.inria.spirals.repairnator.process.step.gatherinfo.GatherTestInformation;
import fr.inria.spirals.repairnator.process.step.paths.ComputeClasspath;
import fr.inria.spirals.repairnator.process.step.paths.ComputeSourceDir;
import fr.inria.spirals.repairnator.process.step.paths.ComputeTestDir;
import fr.inria.spirals.repairnator.serializer.AbstractDataSerializer;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import fr.inria.spirals.repairnator.utils.Utils;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.*;
/**
* Created by urli on 11/07/2017.
*/
public class TestNPERepair {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.ERROR);
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Test
@Ignore
//TODO: Add a test with a failing build from GitHub Actions
public void testNPERepair() throws IOException {
long buildId = 220951790; // repairnator/failingProject simple-npe rerun on 23/01/13
RepairnatorConfig.getInstance().setOutputPath(Files.createTempDirectory("test_nperepair_output").toFile().getAbsolutePath());
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_nperepair").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
RepairnatorConfig.getInstance().setRepairTools(Collections.singleton(NPERepair.TOOL_NAME));
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
NPERepair npeRepair = new NPERepair();
npeRepair.setProjectInspector(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new BuildProject(inspector))
.addNextStep(new TestProject(inspector))
.addNextStep(new ComputeClasspath(inspector, false))
.addNextStep(new ComputeSourceDir(inspector, false, false))
.addNextStep(new ComputeTestDir(inspector, true))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(npeRepair);
cloneStep.execute();
assertFalse(npeRepair.isShouldStop());
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertEquals(stepStatusList.size(), 9);
StepStatus npeStatus = stepStatusList.get(8);
assertThat(npeStatus.getStep(), is(npeRepair));
for (StepStatus stepStatus : stepStatusList) {
assertTrue(stepStatus.isSuccess());
}
String finalStatus = AbstractDataSerializer.getPrettyPrintState(inspector);
assertThat(finalStatus, is("PATCHED"));
List<RepairPatch> allPatches = inspector.getJobStatus().getAllPatches();
assertThat(allPatches.size(), is(6));
assertThat(inspector.getJobStatus().getToolDiagnostic().get(npeRepair.getRepairToolName()), notNullValue());
for (RepairPatch repairPatch : allPatches) {
assertTrue(new File(repairPatch.getFilePath()).exists());
}
}
@Test
@Ignore
//TODO: Add a test with a failing build from GitHub Actions
public void testNPERepairClassScope() throws IOException {
long buildId = 220951924; // repairnator/failingProject npefix-scope
RepairnatorConfig.getInstance().setNPEScope("class");
RepairnatorConfig.getInstance().setOutputPath(Files.createTempDirectory("test_nperepair_output").toFile().getAbsolutePath());
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_nperepair").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
RepairnatorConfig.getInstance().setRepairTools(Collections.singleton(NPERepair.TOOL_NAME));
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
NPERepair npeRepair = new NPERepair();
npeRepair.setProjectInspector(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new BuildProject(inspector))
.addNextStep(new TestProject(inspector))
.addNextStep(new ComputeClasspath(inspector, false))
.addNextStep(new ComputeSourceDir(inspector, false, false))
.addNextStep(new ComputeTestDir(inspector, true))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(npeRepair);
cloneStep.execute();
assertThat(npeRepair.isShouldStop(), is(false));
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertEquals(stepStatusList.size(), 9);
StepStatus npeStatus = stepStatusList.get(8);
assertThat(npeStatus.getStep(), is(npeRepair));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
String finalStatus = AbstractDataSerializer.getPrettyPrintState(inspector);
assertThat(finalStatus, is("PATCHED"));
List<RepairPatch> allPatches = inspector.getJobStatus().getAllPatches();
assertThat(allPatches.size(), is(23));
assertThat(inspector.getJobStatus().getToolDiagnostic().get(npeRepair.getRepairToolName()), notNullValue());
for (RepairPatch repairPatch : allPatches) {
assertTrue(new File(repairPatch.getFilePath()).exists());
}
}
@Test
@Ignore
//TODO: Add a test with a failing build from GitHub Actions
public void testNPERepairPackageScope() throws IOException {
long buildId = 220951924; // repairnator/failingProject npefix-scope
RepairnatorConfig.getInstance().setNPEScope("package");
RepairnatorConfig.getInstance().setOutputPath(Files.createTempDirectory("test_nperepair_output").toFile().getAbsolutePath());
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_nperepair").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
RepairnatorConfig.getInstance().setRepairTools(Collections.singleton(NPERepair.TOOL_NAME));
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
NPERepair npeRepair = new NPERepair();
npeRepair.setProjectInspector(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new BuildProject(inspector))
.addNextStep(new TestProject(inspector))
.addNextStep(new ComputeClasspath(inspector, false))
.addNextStep(new ComputeSourceDir(inspector, false, false))
.addNextStep(new ComputeTestDir(inspector, true))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(npeRepair);
cloneStep.execute();
assertThat(npeRepair.isShouldStop(), is(false));
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertEquals(stepStatusList.size(), 9);
StepStatus npeStatus = stepStatusList.get(8);
assertThat(npeStatus.getStep(), is(npeRepair));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
String finalStatus = AbstractDataSerializer.getPrettyPrintState(inspector);
assertThat(finalStatus, is("PATCHED"));
List<RepairPatch> allPatches = inspector.getJobStatus().getAllPatches();
assertThat(allPatches.size(), is(23));
assertThat(inspector.getJobStatus().getToolDiagnostic().get(npeRepair.getRepairToolName()), notNullValue());
for (RepairPatch repairPatch : allPatches) {
assertTrue(new File(repairPatch.getFilePath()).exists());
}
}
@Test
@Ignore
//TODO: Add a test with a failing build from GitHub Actions
public void testNPERepairStackScope() throws IOException {
long buildId = 220951924; // repairnator/failingProject npefix-scope rerun on 23/01/13
RepairnatorConfig.getInstance().setNPEScope("stack");
RepairnatorConfig.getInstance().setOutputPath(Files.createTempDirectory("test_nperepair_output").toFile().getAbsolutePath());
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_nperepair").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
RepairnatorConfig.getInstance().setRepairTools(Collections.singleton(NPERepair.TOOL_NAME));
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
NPERepair npeRepair = new NPERepair();
npeRepair.setProjectInspector(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new BuildProject(inspector))
.addNextStep(new TestProject(inspector))
.addNextStep(new ComputeClasspath(inspector, false))
.addNextStep(new ComputeSourceDir(inspector, false, false))
.addNextStep(new ComputeTestDir(inspector, true))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(npeRepair);
cloneStep.execute();
assertThat(npeRepair.isShouldStop(), is(false));
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertEquals(stepStatusList.size(), 9);
StepStatus npeStatus = stepStatusList.get(8);
assertThat(npeStatus.getStep(), is(npeRepair));
for (StepStatus stepStatus : stepStatusList) {
assertThat(stepStatus.isSuccess(), is(true));
}
String finalStatus = AbstractDataSerializer.getPrettyPrintState(inspector);
assertThat(finalStatus, is("PATCHED"));
List<RepairPatch> allPatches = inspector.getJobStatus().getAllPatches();
assertThat(allPatches.size(), is(23));
assertThat(inspector.getJobStatus().getToolDiagnostic().get(npeRepair.getRepairToolName()), notNullValue());
for (RepairPatch repairPatch : allPatches) {
assertTrue(new File(repairPatch.getFilePath()).exists());
}
}
@Test
@Ignore
//TODO: Add a test with a failing build from GitHub Actions
public void testNPERepairProjectScope() throws IOException {
long buildId = 220951924; // repairnator/failingProject npefix-scope
RepairnatorConfig.getInstance().setNPEScope("project");
RepairnatorConfig.getInstance().setOutputPath(Files.createTempDirectory("test_nperepair_output").toFile().getAbsolutePath());
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_nperepair").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
RepairnatorConfig.getInstance().setRepairTools(Collections.singleton(NPERepair.TOOL_NAME));
ProjectInspector inspector = new ProjectInspector(toBeInspected, tmpDir.getAbsolutePath(), null, null);
CloneRepository cloneStep = new CloneRepository(inspector);
NPERepair npeRepair = new NPERepair();
npeRepair.setProjectInspector(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true))
.addNextStep(new BuildProject(inspector))
.addNextStep(new TestProject(inspector))
.addNextStep(new ComputeClasspath(inspector, false))
.addNextStep(new ComputeSourceDir(inspector, false, false))
.addNextStep(new ComputeTestDir(inspector, true))
.addNextStep(new GatherTestInformation(inspector, true, new BuildShouldFail(), false))
.addNextStep(npeRepair);
cloneStep.execute();
assertThat(npeRepair.isShouldStop(), is(false));
List<StepStatus> stepStatusList = inspector.getJobStatus().getStepStatuses();
assertEquals(stepStatusList.size(), 9);
StepStatus npeStatus = stepStatusList.get(8);
assertThat(npeStatus.getStep(), is(npeRepair));
for (StepStatus stepStatus : stepStatusList) {
assertTrue(stepStatus.isSuccess());
}
String finalStatus = AbstractDataSerializer.getPrettyPrintState(inspector);
assertThat(finalStatus, is("PATCHED"));
List<RepairPatch> allPatches = inspector.getJobStatus().getAllPatches();
assertEquals(allPatches.size(), 23);
assertThat(inspector.getJobStatus().getToolDiagnostic().get(npeRepair.getRepairToolName()), notNullValue());
for (RepairPatch repairPatch : allPatches) {
assertTrue(new File(repairPatch.getFilePath()).exists());
}
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.repair;
/**
* Created by urli on 10/07/2017.
*
* Refactored by andre15silva on 16/01/2021
*/
public class NPERepair extends AbstractNPERepairStep {
public static final String TOOL_NAME = "NPEFix";
public NPERepair() {
}
@Override
public String getRepairToolName() {
return TOOL_NAME;
}
}
```
|
```package com.github.tdurieux.repair.maven.plugin;
import fr.inria.lille.repair.nopol.NopolStatus;
import org.apache.maven.plugin.Mojo;
import org.junit.Test;
import java.io.File;
public class NopolMojoTest extends BetterAbstractMojoTestCase {
private final String projectPath = "src/test/resources/projects/example1/";
@Override
protected void setUp() throws Exception {
super.setUp();
Process mvn_clean_test = Runtime.getRuntime().exec("mvn clean test", null, new File(projectPath));
mvn_clean_test.waitFor();
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
Process mvn_clean = Runtime.getRuntime().exec("mvn clean", null, new File(projectPath));
mvn_clean.waitFor();
}
@Test
public void testNopolRepair() throws Exception {
File f = getTestFile(projectPath + "pom.xml");
Mojo mojo = lookupConfiguredMojo(f, "nopol");
assertNotNull( mojo );
assertTrue("Wrong class: "+mojo, mojo instanceof NopolMojo);
NopolMojo repair = (NopolMojo) mojo;
repair.execute();
assertEquals(NopolStatus.PATCH, repair.getResult().getNopolStatus());
}
}```
|
Please help me generate a test for this class.
|
```package com.github.tdurieux.repair.maven.plugin;
import com.google.common.io.ByteStreams;
import fr.inria.lille.commons.synthesis.smt.solver.SolverFactory;
import fr.inria.lille.repair.common.config.NopolContext;
import fr.inria.lille.repair.common.patch.Patch;
import fr.inria.lille.repair.common.synth.RepairType;
import fr.inria.lille.repair.nopol.NoPol;
import fr.inria.lille.repair.nopol.NopolResult;
import org.apache.commons.lang3.StringUtils;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static fr.inria.spirals.repairnator.utils.Utils.checkToolsJar;
@Mojo( name = "nopol", aggregator = true,
defaultPhase = LifecyclePhase.TEST,
requiresDependencyResolution = ResolutionScope.TEST)
public class NopolMojo extends AbstractRepairMojo {
private static String HARDCODED_NOPOL_VERSION = "666abb764bf1819f6c316faf4fe5b559ac583de1";
@Parameter( defaultValue = "${project.build.directory}/nopol", property = "outputDir", required = true )
private File outputDirectory;
@Parameter( defaultValue = "pre_then_cond", property = "type", required = true )
private String type;
@Parameter( defaultValue = "10", property = "maxTime", required = true )
private int maxTime;
@Parameter( defaultValue = "cocospoon", property = "localizer", required = true )
private String localizer;
@Parameter( defaultValue = "smt", property = "synthesis", required = true )
private String synthesis;
@Parameter( defaultValue = "z3", property = "solver", required = true )
private String solver;
private NopolResult result;
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
try {
checkToolsJar();
} catch (ClassNotFoundException e) {
throw new MojoExecutionException("tools.jar has not been loaded, therefore Nopol can't run");
}
final List<String> failingTestCases = getFailingTests();
final List<URL> dependencies = getClasspath();
final List<File> sourceFolders = getSourceFolders();
System.out.println(failingTestCases.size() + " detected failing test classes. (" + StringUtils.join(failingTestCases,":") + ")");
final List<URL> nopolClasspath = getNopolClasspath();
final String systemClasspath = System.getProperty("java.class.path");
String strClasspath = getStringClasspathFromList(nopolClasspath, systemClasspath);
try {
setGzoltarDebug(true);
System.setProperty("java.class.path", strClasspath);
NopolContext nopolContext = createNopolContext(failingTestCases, dependencies, sourceFolders);
try {
File currentDir = new File(".").getCanonicalFile();
nopolContext.setRootProject(currentDir.toPath().toAbsolutePath());
} catch (IOException e) {
getLog().error("Error while setting the root project path, the created patches might have absolute paths.");
}
final NoPol nopol = new NoPol(nopolContext);
this.result = nopol.build();
printResults(result);
} finally {
System.setProperty("java.class.path", systemClasspath);
}
}
private void printResults(NopolResult result) {
System.out.println("Nopol executed after: "+result.getDurationInMilliseconds()+" ms.");
System.out.println("Status: "+result.getNopolStatus());
System.out.println("Angelic values: "+result.getNbAngelicValues());
System.out.println("Nb statements: "+result.getNbStatements());
if (result.getPatches().size() > 0) {
for (Patch p : result.getPatches()) {
System.out.println("Obtained patch: "+p.asString());
}
}
}
private NopolContext createNopolContext(List<String> failingTestCases,
List<URL> dependencies, List<File> sourceFolders) {
NopolContext nopolContext = new NopolContext(sourceFolders.toArray(new File[0]), dependencies.toArray(new URL[0]), failingTestCases.toArray(new String[0]), Collections.<String>emptyList());
nopolContext.setComplianceLevel(getComplianceLevel());
nopolContext.setTimeoutTestExecution(300);
nopolContext.setMaxTimeEachTypeOfFixInMinutes(15);
nopolContext.setMaxTimeInMinutes(maxTime);
nopolContext.setLocalizer(this.resolveLocalizer());
nopolContext.setSynthesis(this.resolveSynthesis());
nopolContext.setType(this.resolveType());
nopolContext.setOnlyOneSynthesisResult(true);
nopolContext.setJson(true);
if (!outputDirectory.exists()) {
outputDirectory.mkdirs();
}
nopolContext.setOutputFolder(outputDirectory.getAbsolutePath());
NopolContext.NopolSolver solver = this.resolveSolver();
nopolContext.setSolver(solver);
if (nopolContext.getSynthesis() == NopolContext.NopolSynthesis.SMT) {
if (solver == NopolContext.NopolSolver.Z3) {
String z3Path = this.loadZ3AndGivePath();
SolverFactory.setSolver(solver, z3Path);
nopolContext.setSolverPath(z3Path);
} else {
SolverFactory.setSolver(solver, null);
}
}
return nopolContext;
}
private NopolContext.NopolSolver resolveSolver() {
try {
return NopolContext.NopolSolver.valueOf(solver.toUpperCase());
} catch (IllegalArgumentException e) {
throw new RuntimeException("Solver value \""+solver+"\" is wrong. Only following values are accepted: "+StringUtils.join(NopolContext.NopolSolver.values(),", "));
}
}
private NopolContext.NopolLocalizer resolveLocalizer() {
try {
return NopolContext.NopolLocalizer.valueOf(localizer.toUpperCase());
} catch (IllegalArgumentException e) {
throw new RuntimeException("Localizer value \""+localizer+"\" is wrong. Only following values are accepted: "+StringUtils.join(NopolContext.NopolLocalizer.values(), ","));
}
}
private NopolContext.NopolSynthesis resolveSynthesis() {
try {
return NopolContext.NopolSynthesis.valueOf(synthesis.toUpperCase());
} catch (IllegalArgumentException e) {
throw new RuntimeException("Synthesis value \""+synthesis+"\" is wrong. Only following values are accepted: "+StringUtils.join(NopolContext.NopolSynthesis.values(), ","));
}
}
private RepairType resolveType() {
try {
return RepairType.valueOf(type.toUpperCase());
} catch (IllegalArgumentException e) {
throw new RuntimeException("Type value \""+type+"\" is wrong. Only following values are accepted: "+StringUtils.join(RepairType.values(), ","));
}
}
private String loadZ3AndGivePath() {
boolean isMac = System.getProperty("os.name").toLowerCase().contains("mac");
String resourcePath = (isMac)? "z3/z3_for_mac" : "z3/z3_for_linux";
InputStream in = this.getClass().getClassLoader().getResourceAsStream(resourcePath);
try {
Path tempFilePath = Files.createTempFile("nopol", "z3");
byte[] content = ByteStreams.toByteArray(in);
Files.write(tempFilePath, content);
tempFilePath.toFile().setExecutable(true);
return tempFilePath.toString();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
private List<URL> getNopolClasspath() {
List<URL> classpath = new ArrayList<>();
Artifact artifactPom = artifactFactory.createArtifact("fr.inria.gforge.spirals","nopol", HARDCODED_NOPOL_VERSION, null, "pom");
Artifact artifactJar = artifactFactory.createArtifact("fr.inria.gforge.spirals","nopol", HARDCODED_NOPOL_VERSION, null, "jar");
File filePom = new File(localRepository.getBasedir() + "/" + localRepository.pathOf(artifactPom));
File fileJar = new File(localRepository.getBasedir() + "/" + localRepository.pathOf(artifactJar));
classpath.addAll(getClassPathFromPom(filePom, fileJar));
return classpath;
}
@Override
public List<URL> getClasspath() {
List<URL> classpath = super.getClasspath();
Artifact artifactJar = artifactFactory.createArtifact("fr.inria.gforge.spirals","nopol", HARDCODED_NOPOL_VERSION, null, "jar");
File fileJar = new File(localRepository.getBasedir() + "/" + localRepository.pathOf(artifactJar));
try {
if (fileJar.exists()) {
classpath.add(fileJar.toURI().toURL());
}
String path = System.getProperty("java.home") + "/../lib/tools.jar";
File jarFile = new File(path);
if (jarFile.exists()) {
classpath.add(jarFile.toURI().toURL());
}
} catch (Exception e) {
e.printStackTrace();
System.err.println("Error occurred, dependency will be passed: "+e.getMessage());
}
return new ArrayList<>(classpath);
}
public NopolResult getResult() {
return result;
}
}
```
|
```package fr.inria.spirals.repairnator.config;
import fr.inria.spirals.repairnator.utils.Utils;
import org.junit.After;
import org.junit.Ignore;
import org.junit.Test;
import org.kohsuke.github.GHRateLimit;
import org.kohsuke.github.GitHub;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
/**
* Created by urli on 08/03/2017.
*/
public class TestRepairnatorConfig {
private static final String CURRENT_USERDIR = System.getProperty("user.dir");
@After
public void tearDown() {
System.setProperty("user.dir", CURRENT_USERDIR);
}
@Ignore
@Test
public void testReadConfigFromIniInResources() throws RepairnatorConfigException {
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.readFromFile();
assertThat(config.getOutputPath(), is("/tmp"));
assertThat(config.isClean(), is(true));
assertThat(config.isPush(), is(false));
assertThat(config.getLauncherMode(), nullValue());
assertThat(config.getWorkspacePath(), is("./workspace"));
assertThat(config.getZ3solverPath(), is(""));
}
@Ignore
@Test
public void testReadConfigFromUserDir() throws IOException, RepairnatorConfigException {
Path tempUserDir = Files.createTempDirectory("temp-user-dir");
File resourceConfig = new File("src/test/resources/example_config.ini");
File dest = new File(tempUserDir.toFile().getAbsolutePath()+"/"+RepairnatorConfigReader.FILENAME);
Files.copy(resourceConfig.toPath(), dest.toPath());
System.setProperty("user.dir", tempUserDir.toFile().getAbsolutePath());
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.readFromFile();
assertThat(config.getOutputPath(), is(""));
assertThat(config.isClean(), is(true));
assertThat(config.isPush(), is(true));
assertThat(config.getLauncherMode(), nullValue());
assertThat(config.getWorkspacePath(), is("/tmp"));
assertThat(config.getZ3solverPath(), is("/tmp/z3/z3_for_linux"));
System.setProperty("user.dir", CURRENT_USERDIR);
}
/**
* This test is not needed anymore: all github OAuth token are given directly in the command line.
* @throws IOException
*/
@Ignore
@Test
public void testGithubOauth() throws IOException {
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setGithubToken(System.getenv(Utils.GITHUB_OAUTH));
GitHub gitHub = config.getGithub();
GHRateLimit ghRateLimit = gitHub.rateLimit();
assertEquals("OAuth is not working", 5000, ghRateLimit.limit);
}
@Test
public void testToString() {
String s = RepairnatorConfig.getInstance().toString();
assertNotNull(s);
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.config;
import fr.inria.jtravis.JTravis;
import fr.inria.spirals.repairnator.states.BearsMode;
import fr.inria.spirals.repairnator.states.LauncherMode;
import org.apache.commons.lang3.StringUtils;
import org.kohsuke.github.GitHub;
import java.io.File;
import java.io.IOException;
import java.time.Duration;
import java.util.*;
/**
* Created by urli on 08/03/2017.
*/
public class RepairnatorConfig {
public enum PIPELINE_MODE {
DOCKER("fr.inria.spirals.repairnator.realtime.DockerPipelineRunner"),
KUBERNETES("fr.inria.spirals.repairnator.realtime.ActiveMQPipelineRunner"),
NOOP("fr.inria.spirals.repairnator.realtime.NoopRunner");
private final String klass;
PIPELINE_MODE(String s) {
this.klass = s;
}
public String getKlass() {
return klass;
}
}
public enum LISTENER_MODE {
KUBERNETES("fr.inria.spirals.repairnator.pipeline.PipelineBuildListener"),
NOOP("fr.inria.spirals.repairnator.pipeline.NoopListener");
private final String klass;
LISTENER_MODE(String s) {
this.klass = s;
}
public String getKlass() {
return klass;
}
}
public enum PATCH_CLASSIFICATION_MODE {
NONE,
ODS
}
public enum PATCH_FILTERING_MODE {
NONE,
ODS_CORRECT
}
private String runId;
private LauncherMode launcherMode = LauncherMode.REPAIR;
private String inputPath;
private String outputPath;
private String mongodbHost;
private String mongodbName;
private String smtpServer;
private int smtpPort = 25;
private boolean smtpTLS;
private String smtpUsername;
private String smtpPassword;
private String[] notifyTo;
private boolean notifyEndProcess;
private boolean push;
private String pushRemoteRepo;
private boolean fork;
private boolean createPR;
private boolean debug;
private boolean noTravisRepair;
// Scanner
private Date lookFromDate;
private Date lookToDate;
private BearsMode bearsMode = BearsMode.BOTH;
private boolean bearsDelimiter;
private String activeMQListenQueueName;
// Pipeline
private int buildId;
private int nextBuildId;
private String z3solverPath;
private String workspacePath;
private boolean tempWorkspace;
private String githubToken;
private String projectsToIgnoreFilePath;
private Set<String> repairTools;
private Set<String> feedbackTools;
private String githubUserName;
private String githubUserEmail;
private String[] experimentalPluginRepoList;
private LISTENER_MODE listenerMode;
private String gitUrl;
private String gitBranch;
private String gitCommitHash;
private String mavenHome;
private String localMavenRepository;
private String jTravisEndpoint;
private String travisToken;
private String ODSPath;
private String gitRepositoryUrl;
private String gitRepositoryBranch;
private String gitRepositoryIdCommit;
private boolean gitRepositoryFirstCommit = false;
private Integer gitRepositoryPullRequest;
private String[] sonarRules;
private boolean isStaticAnalysis;
private boolean measureSoraldTime;
private String npeSelection;
private Integer npeNbIteration;
private String npeScope;
private String npeRepairStrategy;
private Double flacocoThreshold;
private Integer flacocoTopK;
private String flacocoResultsRepository;
private PATCH_CLASSIFICATION_MODE patchClassificationMode;
private PATCH_FILTERING_MODE patchFilteringMode;
private boolean patchClassification;
private boolean patchFiltering;
// Dockerpool
private String dockerImageName;
private boolean skipDelete;
private boolean createOutputDir;
private String logDirectory;
private int nbThreads = 1; // safe default value
private int globalTimeout;
// Realtime
private File whiteList;
private File blackList;
private File projectsToScan;
private int jobSleepTime;
private int buildSleepTime;
private int maxInspectedBuilds;
private Duration duration;
private Duration summaryFrequency;
private String[] notifySummary;
private int numberOfPatchedBuilds;
private int numberOfPRs;
private PIPELINE_MODE pipelineMode;
private String activeMQUrl;
private String activeMQSubmitQueueName;
private String activeMQUsername;
private String activeMQPassword;
// BuildRainer
private String webSocketUrl;
private String jmxHostName;
private int queueLimit;
// Checkbranches
private boolean humanPatch;
private String repository;
private boolean clean;
private boolean commandFunctionality;
private static RepairnatorConfig instance;
private RepairnatorConfig() {
this.repairTools = new HashSet<>();
this.feedbackTools = new HashSet<>();
}
public void readFromFile() throws RepairnatorConfigException {
RepairnatorConfigReader configReader = new RepairnatorConfigReader();
configReader.readConfigFile(this);
}
// for test purpose
public static void deleteInstance() {
instance = null;
}
public static RepairnatorConfig getInstance() {
if (instance == null) {
instance = new RepairnatorConfig();
}
return instance;
}
public String getRunId() {
return runId;
}
public void setListenerMode(String listenerMode) {
for (LISTENER_MODE mode: LISTENER_MODE.values()) {
if (listenerMode.equals(mode.name())) {
this.listenerMode = LISTENER_MODE.valueOf(listenerMode);
return;
}
}
throw new RuntimeException("unknown listener "+listenerMode);
}
public LISTENER_MODE getListenerMode() {
return this.listenerMode;
}
public void setPipelineMode(String pipelineMode) {
for (PIPELINE_MODE mode: PIPELINE_MODE.values()) {
if (pipelineMode.equals(mode.name())) {
this.pipelineMode = PIPELINE_MODE.valueOf(pipelineMode);
return;
}
}
throw new RuntimeException("unknown pipeline "+pipelineMode);
}
public PIPELINE_MODE getPipelineMode() {
return this.pipelineMode;
}
public void setActiveMQUrl(String activeMQUrl) {
this.activeMQUrl = activeMQUrl;
}
public String getActiveMQUrl() {
return this.activeMQUrl;
}
public void setActiveMQSubmitQueueName(String activeMQSubmitQueueName) {
this.activeMQSubmitQueueName = activeMQSubmitQueueName;
}
public String getActiveMQSubmitQueueName() {
return this.activeMQSubmitQueueName;
}
public void setActiveMQListenQueueName(String activeMQListenQueueName) {
this.activeMQListenQueueName = activeMQListenQueueName;
}
public String getActiveMQListenQueueName() {
return this.activeMQListenQueueName;
}
public void setActiveMQUsername(String activeMQUsername) {
this.activeMQUsername = activeMQUsername;
}
public String getActiveMQUsername() { return activeMQUsername; }
public void setActiveMQPassword(String activeMQPassword) {
this.activeMQPassword = activeMQPassword;
}
public String getActiveMQPassword() { return activeMQPassword; }
public void setWebSocketUrl(String webSocketUrl) {
this.webSocketUrl = webSocketUrl;
}
public String getWebSocketUrl() {
return this.webSocketUrl;
}
public void setJmxHostName(String jmxHostName) {
this.jmxHostName = jmxHostName;
}
public String getJmxHostName() {
return this.jmxHostName;
}
public void setQueueLimit(int queueLimit) {
this.queueLimit = queueLimit;
}
public int getQueueLimit() {
return this.queueLimit;
}
public void setRunId(String runId) {
this.runId = runId;
}
public LauncherMode getLauncherMode() {
return launcherMode;
}
public void setLauncherMode(LauncherMode launcherMode) {
this.launcherMode = launcherMode;
}
public String getInputPath() {
return inputPath;
}
public void setInputPath(String inputPath) {
this.inputPath = inputPath;
}
public String getOutputPath() {
return outputPath;
}
public void setOutputPath(String outputPath) {
this.outputPath = outputPath;
}
public String getMongodbHost() {
return mongodbHost;
}
public void setMongodbHost(String mongodbHost) {
this.mongodbHost = mongodbHost;
}
public String getMongodbName() {
return mongodbName;
}
public void setMongodbName(String mongodbName) {
this.mongodbName = mongodbName;
}
public String getSmtpServer() {
return smtpServer;
}
public void setSmtpServer(String smtpServer) {
this.smtpServer = smtpServer;
}
public int getSmtpPort() {
return smtpPort;
}
public void setSmtpPort(int smtpPort) {
this.smtpPort = smtpPort;
}
public boolean isSmtpTLS() {
return smtpTLS;
}
public void setSmtpTLS(boolean smtpTLS) {
this.smtpTLS = smtpTLS;
}
public String getSmtpUsername() {
return smtpUsername;
}
public void setSmtpUsername(String smtpUsername) {
this.smtpUsername = smtpUsername;
}
public String getSmtpPassword() {
return smtpPassword;
}
public void setSmtpPassword(String smtpPassword) {
this.smtpPassword = smtpPassword;
}
public String[] getNotifyTo() {
return notifyTo;
}
public void setNotifyTo(String[] notifyTo) {
this.notifyTo = notifyTo;
}
public boolean isNotifyEndProcess() {
return notifyEndProcess;
}
public void setNotifyEndProcess(boolean notifyEndProcess) {
this.notifyEndProcess = notifyEndProcess;
}
public boolean isPush() {
return push;
}
public void setPush(boolean push) {
this.push = push;
}
public String getPushRemoteRepo() {
return pushRemoteRepo;
}
public void setPushRemoteRepo(String pushRemoteRepo) {
this.pushRemoteRepo = pushRemoteRepo;
}
public boolean isFork() {
return fork;
}
public void setFork(boolean fork) {
this.fork = fork;
}
public boolean isDebug() {
return debug;
}
public void setDebug(boolean debug) {
this.debug = debug;
}
public int getBuildId() {
return buildId;
}
public void setBuildId(int buildId) {
this.buildId = buildId;
}
public int getNextBuildId() {
return nextBuildId;
}
public void setNextBuildId(int nextBuildId) {
this.nextBuildId = nextBuildId;
}
public String getZ3solverPath() {
return z3solverPath;
}
public void setZ3solverPath(String z3solverPath) {
this.z3solverPath = z3solverPath;
}
public String getWorkspacePath() {
return workspacePath;
}
public void setWorkspacePath(String workspacePath) {
this.workspacePath = workspacePath;
}
public boolean getTempWorkspace() {
return tempWorkspace;
}
public void setTempWorkspace(boolean tempWorkspace) {
this.tempWorkspace = tempWorkspace;
}
public String getGithubToken() {
return githubToken;
}
public void setGithubToken(String githubToken) {
this.githubToken = githubToken;
}
public String getProjectsToIgnoreFilePath() {
return projectsToIgnoreFilePath;
}
public void setProjectsToIgnoreFilePath(String projectsToIgnoreFilePath) {
this.projectsToIgnoreFilePath = projectsToIgnoreFilePath;
}
public Date getLookFromDate() {
return lookFromDate;
}
public void setLookFromDate(Date lookFromDate) {
this.lookFromDate = lookFromDate;
}
public Date getLookToDate() {
return lookToDate;
}
public void setLookToDate(Date lookToDate) {
this.lookToDate = lookToDate;
}
public String getDockerImageName() {
return dockerImageName;
}
public void setDockerImageName(String dockerImageName) {
this.dockerImageName = dockerImageName;
}
public boolean isSkipDelete() {
return skipDelete;
}
public void setSkipDelete(boolean skipDelete) {
this.skipDelete = skipDelete;
}
public boolean isCreateOutputDir() {
return createOutputDir;
}
public void setCreateOutputDir(boolean createOutputDir) {
this.createOutputDir = createOutputDir;
}
public String getLogDirectory() {
return logDirectory;
}
public void setLogDirectory(String logDirectory) {
this.logDirectory = logDirectory;
}
public int getNbThreads() {
return nbThreads;
}
public void setNbThreads(int nbThreads) {
this.nbThreads = nbThreads;
}
public int getGlobalTimeout() {
return globalTimeout;
}
public void setGlobalTimeout(int globalTimeout) {
this.globalTimeout = globalTimeout;
}
public File getWhiteList() {
return whiteList;
}
public void setWhiteList(File whiteList) {
this.whiteList = whiteList;
}
public File getBlackList() {
return blackList;
}
public void setBlackList(File blackList) {
this.blackList = blackList;
}
public File getProjectsToScan() {
return projectsToScan;
}
public void setProjectsToScan(File projectsToScan) {
this.projectsToScan = projectsToScan;
}
public int getJobSleepTime() {
return jobSleepTime;
}
public void setJobSleepTime(int jobSleepTime) {
this.jobSleepTime = jobSleepTime;
}
public int getBuildSleepTime() {
return buildSleepTime;
}
public void setBuildSleepTime(int buildSleepTime) {
this.buildSleepTime = buildSleepTime;
}
public int getMaxInspectedBuilds() {
return maxInspectedBuilds;
}
public void setMaxInspectedBuilds(int maxInspectedBuilds) {
this.maxInspectedBuilds = maxInspectedBuilds;
}
public Duration getDuration() {
return duration;
}
public void setDuration(Duration duration) {
this.duration = duration;
}
public boolean isHumanPatch() {
return humanPatch;
}
public void setHumanPatch(boolean humanPatch) {
this.humanPatch = humanPatch;
}
public String getRepository() {
return repository;
}
public void setRepository(String repository) {
this.repository = repository;
}
public boolean isClean() {
return clean;
}
public void setClean(boolean clean) {
this.clean = clean;
}
public static void setInstance(RepairnatorConfig instance) {
RepairnatorConfig.instance = instance;
}
public GitHub getGithub() throws IOException {
return this.getJTravis().getGithub();
}
public JTravis getJTravis() {
JTravis.Builder builder = JTravis.builder().setGithubToken(this.getGithubToken());
if(this.getJTravisEndpoint() != null && !this.getJTravisEndpoint().equals("")) {
builder.setEndpoint(this.getJTravisEndpoint());
}
if(this.getTravisToken() != null && !this.getTravisToken().equals("")) {
builder.setTravisToken("token " + this.getTravisToken());
}
return builder.build();
}
public BearsMode getBearsMode() {
return bearsMode;
}
public void setBearsMode(BearsMode bearsMode) {
this.bearsMode = bearsMode;
}
public Set<String> getRepairTools() {
return repairTools;
}
public void setRepairTools(Set<String> repairTools) {
this.repairTools = repairTools;
}
public Set<String> getFeedbackTools() {
return feedbackTools;
}
public void setFeedbackTools(Set<String> feedbackTools) {
this.feedbackTools = feedbackTools;
}
public boolean isBearsDelimiter() {
return bearsDelimiter;
}
public void setBearsDelimiter(boolean bearsDelimiter) {
this.bearsDelimiter = bearsDelimiter;
}
public void setGitUrl(String gitUrl) {
this.gitUrl = gitUrl;
}
public void setGitBranch(String gitBranch) {
this.gitBranch = gitBranch;
}
public void setGitCommitHash(String gitCommitHash) {
this.gitCommitHash = gitCommitHash;
}
public String getGitUrl() {
return this.gitUrl;
}
public String getGitBranch() {
return this.gitBranch;
}
public String getGitCommitHash() {
return this.gitCommitHash;
}
public String getGithubUserName() {
return githubUserName;
}
public void setGithubUserName(String githubUserName) {
this.githubUserName = githubUserName;
}
public String getGithubUserEmail() {
return githubUserEmail;
}
public void setGithubUserEmail(String githubUserEmail) {
this.githubUserEmail = githubUserEmail;
}
public void setMavenHome(String mavenHome) {
this.mavenHome = mavenHome;
}
public String getMavenHome() {
return this.mavenHome;
}
public String getLocalMavenRepository() {
if (localMavenRepository == null) {
setLocalMavenRepository(System.getProperty("user.home") + "/.m2/repository");
}
return localMavenRepository;
}
public void setLocalMavenRepository(String localMavenRepository) {
this.localMavenRepository = localMavenRepository;
}
public boolean isCreatePR() {
return createPR;
}
public void setCreatePR(boolean createPR) {
this.createPR = createPR;
}
public void setNoTravisRepair(boolean noTravisRepair) {
this.noTravisRepair = noTravisRepair;
}
public boolean isNoTravisRepair() {
return this.noTravisRepair;
}
public void setSonarRules(String[] sonarRules) {
this.sonarRules = sonarRules;
}
public String[] getSonarRules() {
return this.sonarRules;
}
public void setIsStaticAnalysis(boolean isStaticAnalysis) {
this.isStaticAnalysis = isStaticAnalysis;
}
public boolean isStaticAnalysis() {
return this.isStaticAnalysis;
}
public String getNPESelection() {
return npeSelection;
}
public void setNPESelection(String npeSelection) {
this.npeSelection = npeSelection;
}
public Integer getNPENbIteration() {
return npeNbIteration;
}
public void setNPENbIteration(Integer npeNbIteration) {
this.npeNbIteration = npeNbIteration;
}
public String getNPEScope() {
return npeScope;
}
public void setNPEScope(String npeScope) {
this.npeScope = npeScope;
}
public String getNPERepairStrategy() {
return npeRepairStrategy;
}
public void setNPERepairStrategy(String npeRepairStrategy) {
this.npeRepairStrategy = npeRepairStrategy;
}
public Double getFlacocoThreshold() {
return flacocoThreshold;
}
public void setFlacocoThreshold(Double flacocoThreshold) {
this.flacocoThreshold = flacocoThreshold;
}
public Integer getFlacocoTopK() {
return flacocoTopK;
}
public void setFlacocoTopK(Integer flacocoTopK) {
this.flacocoTopK = flacocoTopK;
}
public String getFlacocoResultsRepository() {
return flacocoResultsRepository;
}
public void setFlacocoResultsRepository(String flacocoResultsRepository) {
this.flacocoResultsRepository = flacocoResultsRepository;
}
@Override
public String toString() {
String ghToken = this.getGithubToken();
if (ghToken != null && !ghToken.isEmpty()) {
ghToken = (ghToken.length() > 10) ? ghToken.substring(0,10)+"[...]" : ghToken;
}
String mongoDbInfo = this.getMongodbHost();
if (mongoDbInfo != null && !mongoDbInfo.isEmpty()) {
int indexOfArobase = mongoDbInfo.indexOf('@');
if (indexOfArobase != -1) {
mongoDbInfo = "mongodb://[hidden]" + mongoDbInfo.substring(indexOfArobase);
}
}
// In case we have a password, print out stars, if there is no password print nothing
String smtpPass = "";
if(smtpPassword != null) smtpPass = "*****";
return "RepairnatorConfig{" +
"runId='" + runId + '\'' +
", launcherMode=" + launcherMode +
", inputPath='" + inputPath + '\'' +
", outputPath='" + outputPath + '\'' +
", mongodbHost='" + mongoDbInfo + '\'' +
", mongodbName='" + mongodbName + '\'' +
", smtpServer='" + smtpServer + '\'' +
", smtpPort='" + smtpPort + '\'' +
", smtpTLS='" + smtpTLS + '\'' +
", smtpUsername='" + smtpUsername + '\'' +
", smtpPassword='" + smtpPass + '\'' +
", notifyTo=" + Arrays.toString(notifyTo) +
", notifyEndProcess=" + notifyEndProcess +
", push=" + push +
", pushRemoteRepo='" + pushRemoteRepo + '\'' +
", fork=" + fork +
", lookFromDate=" + lookFromDate +
", lookToDate=" + lookToDate +
", buildId=" + buildId +
", z3solverPath='" + z3solverPath + '\'' +
", workspacePath='" + workspacePath + '\'' +
", githubToken='" + ghToken + '\'' +
", dockerImageName='" + dockerImageName + '\'' +
", skipDelete=" + skipDelete +
", createOutputDir=" + createOutputDir +
", logDirectory='" + logDirectory + '\'' +
", nbThreads=" + nbThreads +
", globalTimeout=" + globalTimeout +
", whiteList=" + whiteList +
", blackList=" + blackList +
", jobSleepTime=" + jobSleepTime +
", buildSleepTime=" + buildSleepTime +
", maxInspectedBuilds=" + maxInspectedBuilds +
", duration=" + duration +
", humanPatch=" + humanPatch +
", repository='" + repository + '\'' +
", clean=" + clean +
", bearsMode=" + bearsMode.name() +
", bearsDelimiter = " + bearsDelimiter +
", repairTools=" + StringUtils.join(this.repairTools, ",") +
", githubUserName= " + githubUserName +
", githubUserEmail=" + githubUserEmail +
", pipelineMode=" + pipelineMode +
", listenerMode=" + listenerMode +
", activeMQUrl=" + activeMQUrl +
", activeMQSubmitQueueName=" + activeMQSubmitQueueName +
", gitUrl=" + gitUrl +
", gitBranch=" + gitBranch +
", gitCommitHash=" + gitCommitHash +
", mavenHome=" + mavenHome +
", localMavenRepository=" + localMavenRepository +
", noTravisRepair=" + noTravisRepair +
", jTravisEndpoint=" + jTravisEndpoint +
", travisToken=" + travisToken +
", flacocoThreshold=" + flacocoThreshold +
", flacocoTopK=" + flacocoTopK +
", flacocoResultsRepository=" + flacocoResultsRepository +
'}';
}
public Duration getSummaryFrequency() {
return summaryFrequency;
}
public void setSummaryFrequency(Duration summaryFrequency) {
this.summaryFrequency = summaryFrequency;
}
public String[] getNotifySummary() {
return notifySummary;
}
public void setNotifySummary(String[] notifySummary) {
this.notifySummary = notifySummary;
}
public int getNumberOfPRs() {
return numberOfPRs;
}
public void setNumberOfPRs(int numberOfPRs) {
this.numberOfPRs = numberOfPRs;
}
public String[] getExperimentalPluginRepoList() {
return experimentalPluginRepoList;
}
public void setExperimentalPluginRepoList(String[] experimentalPluginRepoList) {
this.experimentalPluginRepoList = experimentalPluginRepoList;
}
public int getNumberOfPatchedBuilds() {
return numberOfPatchedBuilds;
}
public void setNumberOfPatchedBuilds(int numberOfPatchedBuilds) {
this.numberOfPatchedBuilds = numberOfPatchedBuilds;
}
public String getGitRepositoryUrl() {
return gitRepositoryUrl;
}
public void setGitRepositoryUrl(String gitRepositoryUrl) {
this.gitRepositoryUrl = gitRepositoryUrl;
}
public String getGitRepositoryBranch() {
return gitRepositoryBranch;
}
public void setGitRepositoryBranch(String gitRepositoryBranch) {
this.gitRepositoryBranch = gitRepositoryBranch;
}
public String getGitRepositoryIdCommit() {
return this.gitCommitHash;
}
public void setGitRepositoryIdCommit(String gitRepositoryIdCommit) {
this.gitRepositoryIdCommit = gitRepositoryIdCommit;
}
public boolean isGitRepositoryFirstCommit() {
return gitRepositoryFirstCommit;
}
public void setGitRepositoryFirstCommit(boolean gitRepositoryFirstCommit) {
this.gitRepositoryFirstCommit = gitRepositoryFirstCommit;
}
public Integer getGitRepositoryPullRequest() {
return gitRepositoryPullRequest;
}
public void setGitRepositoryPullRequest(Integer gitRepositoryPullRequest) {
this.gitRepositoryPullRequest = gitRepositoryPullRequest;
}
public String getGitRepositoryId() {
try {
String repoId= getGitRepositoryUrl().split("https://gits-15.sys.kth.se/",2)[1].replace(".git","").replace("/", "-") + "-" + (getGitRepositoryBranch() != null ? getGitRepositoryBranch() : "master") +
(getGitRepositoryIdCommit() != null ? "-" + getGitRepositoryIdCommit() : "") +
(isGitRepositoryFirstCommit() ? "-firstCommit" : "");
return repoId;
} catch (Exception e) {
System.out.println("Repo ot found in KTH Github server");
}
String repoId= getGitRepositoryUrl().split("https://github.com/",2)[1].replace(".git","").replace("/", "-") + "-" + (getGitRepositoryBranch() != null ? getGitRepositoryBranch() : "master") +
(getGitRepositoryIdCommit() != null ? "-" + getGitRepositoryIdCommit() : "") +
(isGitRepositoryFirstCommit() ? "-firstCommit" : "");
return repoId;
}
public String getJTravisEndpoint() {
return jTravisEndpoint;
}
public void setJTravisEndpoint(String jTravisEndpoint) {
this.jTravisEndpoint = jTravisEndpoint;
}
public String getTravisToken() {
return travisToken;
}
public void setTravisToken(String travisToken) {
this.travisToken = travisToken;
}
public String getODSPath() {
return ODSPath;
}
public void setODSPath(String ODSPath) {
this.ODSPath = ODSPath;
}
public PATCH_CLASSIFICATION_MODE getPatchClassificationMode() {
return patchClassificationMode;
}
public void setPatchClassificationMode(PATCH_CLASSIFICATION_MODE patchClassificationMode) {
this.patchClassificationMode = patchClassificationMode;
}
public boolean isPatchClassification() {
return patchClassification;
}
public void setPatchClassification(boolean patchClassification) {
this.patchClassification = patchClassification;
}
public PATCH_FILTERING_MODE getPatchFilteringMode() {
return patchFilteringMode;
}
public void setPatchFilteringMode(PATCH_FILTERING_MODE patchFilteringMode) {
this.patchFilteringMode = patchFilteringMode;
}
public boolean isPatchFiltering() {
return patchFiltering;
}
public void setPatchFiltering(boolean patchFiltering) {
this.patchFiltering = patchFiltering;
}
public boolean getCommandFunctionality(){
return commandFunctionality;
}
public void setCommandFunctionality(boolean command){
this.commandFunctionality = command;
}
}
```
|
```package fr.inria.spirals.repairnator.process.maven;
import com.google.common.io.Files;
import org.apache.maven.model.Model;
import org.apache.maven.model.building.ModelBuildingException;
import org.junit.Test;
import java.io.File;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
public class TestMavenHelper {
@Test
public void testGetMavenModel() {
File javaParserPom = new File("./src/test/resources/pom-examples/javaparser-pom.xml");
File tempM2 = Files.createTempDir();
Model model = MavenHelper.readPomXml(javaParserPom, tempM2.getAbsolutePath());
assertNotNull(model);
assertEquals(8, model.getModules().size());
}
}```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.maven;
import com.mongodb.AggregationOptions;
import com.thoughtworks.qdox.builder.ModelBuilderFactory;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.maven.output.MavenErrorHandler;
import fr.inria.spirals.repairnator.process.maven.output.MavenFilterOutputHandler;
import fr.inria.spirals.repairnator.process.maven.output.MavenMuteOutputHandler;
import org.apache.maven.model.Model;
import org.apache.maven.model.building.*;
import org.apache.maven.shared.invoker.InvocationOutputHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Properties;
/**
* This class intends to help the usage of maven goals in Repairnator
*/
public class MavenHelper {
private static final Logger LOGGER = LoggerFactory.getLogger(MavenHelper.class);
public static final int MAVEN_SUCCESS = 0;
public static final int MAVEN_ERROR = 1;
public static final String SKIP_TEST_PROPERTY = "maven.test.skip.exec";
// all the goals we want to skip
// fixme: make that list available in a config
private static final List<String> SKIP_LIST = Arrays.asList(
"enforcer.skip",
// "checkstyle.skip",
"cobertura.skip",
"skipITs",
"rat.skip",
"license.skip",
"findbugs.skip",
"gpg.skip",
"skip.npm",
"skip.gulp",
"skip.bower",
"dependency-check.skip"
);
private static final int TIMEOUT_WITHOUT_OUTPUT = 10; // in minutes
private final Logger logger = LoggerFactory.getLogger(MavenHelper.class);
private String goal;
private String pomFile;
private Properties properties;
private String name;
private ProjectInspector inspector;
private Instant limitOutputDate;
private boolean skipCheckstyle;
private InvocationOutputHandler errorHandler;
private InvocationOutputHandler outputHandler;
public MavenHelper(String pomFile, String goal, Properties properties, String name, ProjectInspector inspector) {
this(pomFile, goal, properties, name, inspector, true);
}
public MavenHelper(String pomFile, String goal, Properties properties, String name, ProjectInspector inspector, boolean skipCheckstyle) {
this.goal = goal;
this.pomFile = pomFile;
this.properties = properties;
this.name = name;
this.inspector = inspector;
this.skipCheckstyle = skipCheckstyle;
this.errorHandler = new MavenErrorHandler(this);
this.outputHandler = new MavenFilterOutputHandler(this);
this.updateProperties();
}
private void updateProperties() {
if (this.properties == null) {
this.properties = new Properties();
}
// we want to use a dedicated Maven repository
this.properties.setProperty("maven.repo.local", this.inspector.getM2LocalPath());
for (String skip : SKIP_LIST) {
this.properties.setProperty(skip, "true");
}
if (this.skipCheckstyle) {
this.properties.setProperty("checkstyle.skip", "true");
}
}
public String getGoal() {
return goal;
}
public String getPomFile() {
return pomFile;
}
public Properties getProperties() {
return properties;
}
public String getName() {
return name;
}
public ProjectInspector getInspector() {
return inspector;
}
public InvocationOutputHandler getErrorHandler() {
return errorHandler;
}
public InvocationOutputHandler getOutputHandler() {
return outputHandler;
}
public void updateLastOutputDate() {
this.limitOutputDate = new Date().toInstant().plus(TIMEOUT_WITHOUT_OUTPUT, ChronoUnit.MINUTES);
}
public void setErrorHandler(InvocationOutputHandler errorHandler) {
this.errorHandler = errorHandler;
}
public void setOutputHandler(InvocationOutputHandler outputHandler) {
this.outputHandler = outputHandler;
}
public static Model readPomXml(File pomXml, String localMavenRepository) {
ModelBuildingRequest req = new DefaultModelBuildingRequest();
req.setProcessPlugins(true);
req.setPomFile(pomXml);
req.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
req.setModelResolver(new RepositoryModelResolver(localMavenRepository));
ModelBuilder modelBuilder = new DefaultModelBuilderFactory().newInstance();
// we try to build the model, and if we fail, we try to get the raw model
try {
ModelBuildingResult modelBuildingResult = modelBuilder.build(req);
return modelBuildingResult.getEffectiveModel();
} catch (ModelBuildingException e) {
LOGGER.error("Error while building complete model. The raw model will be used. Error message: " + e.getMessage());
return modelBuilder.buildRawModel(pomXml, ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL, true).get();
}
}
// we manage our own timeout
public int run() throws InterruptedException {
RunnableMavenInvoker runnableMavenInvoker = new RunnableMavenInvoker(this);
Thread t = new Thread(runnableMavenInvoker);
this.updateLastOutputDate();
t.start();
while (t.isAlive()) {
Instant now = new Date().toInstant();
if (now.isAfter(this.limitOutputDate)) {
t.interrupt();
throw new InterruptedException("Timeout occurred: no output has been received in the last " + TIMEOUT_WITHOUT_OUTPUT + " minutes.");
} else {
Thread.sleep(1000);
}
}
return runnableMavenInvoker.getExitCode();
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.logParser;
import org.apache.commons.io.IOUtils;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.util.List;
import java.util.stream.Collectors;
import static org.junit.Assert.assertEquals;
public class TestLogParser {
@Test
public void TestLogParserCompilationError() throws IOException {
LogParser p = new LogParser();
String log = loadLogFromResources("/test-logparser/compilation-error.dat");
p.parse(log);
List<Element> errors = p.getErrors();
assertEquals(2, errors.size());
Element error = errors.get(0);
assertEquals(error.<String>get("file"), "/home/javier/failingProject/src/main/java/symbolic_examples/symbolic_example_3/NopolExample.java");
assertEquals(error.<Integer>get("line").intValue(), 22);
assertEquals(error.<Integer>get("column").intValue(), 49);
assertEquals(error.<String>get("message"), "\';\' expected");
}
String loadLogFromResources(String path) throws IOException{
InputStream is = getClass().getResourceAsStream(path);
StringWriter writer = new StringWriter();
IOUtils.copy(is, writer);
return writer.toString();
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.logParser;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Maven/Java log parser
* Reproduced from tdurieux/Travis-Listener implementation
*
* Author: Javier Ron
*/
public class LogParser {
List<Independent> independents;
List<Group> groups;
List<Element> tests;
List<Element> errors;
String inGroup;
Element currentElement;
public LogParser(){
independents = new ArrayList<>();
independents.add(new Independent(Pattern.compile("\\[javac] (?<file>[^:]+):(?<line>[0-9]+): error: (?<message>.*)"), "test", "Test"));
independents.add(new Independent(Pattern.compile("\\[ERROR] (?<file>[^:]+):\\[(?<line>[0-9]+)(,(?<column>[0-9]+))?] (?<message>\\((.+)\\) (.+))\\."), "test", "Test"));
groups = new ArrayList<>();
groups.add(new Group("checkstyle", "Checkstyle", "Chore",
Pattern.compile("\\[INFO] There (is|are) (.+) errors? reported by Checkstyle .+ with (.+) ruleset\\."),
Pattern.compile("\\[INFO] -+"),
Pattern.compile("\\[ERROR] (?<file>[^:]+):\\[(?<line>[0-9]+)(,(?<column>[0-9]+))?] (?<message>.+)\\.")
));
groups.add(new Group("compile", "Compilation", "Compilation",
Pattern.compile(".*\\[ERROR] COMPILATION ERROR.*"),
Pattern.compile(".*\\[INFO] ([0-9]+) errors?"),
Pattern.compile("\\[ERROR] (?<file>[^:]+):\\[(?<line>[0-9]+)(,(?<column>[0-9]+))?] (?<message>.+)")
));
groups.add(new Group("compile", "Compilation", "Compilation",
Pattern.compile(".*\\[ERROR] COMPILATION ERROR.*"),
Pattern.compile(".*location: +(.+)"),
Pattern.compile(".*\\[ERROR] (?<file>[^:]+):\\[(?<line>[0-9]+)(,(?<column>[0-9]+))?] (?<message>.+)")
));
groups.add(new Group("compile", "Compilation", "Compilation",
Pattern.compile(".*\\[ERROR] COMPILATION ERROR.*"),
Pattern.compile(".*location: +(.+)"),
Pattern.compile("(?<file>[^:]+):\\[(?<line>[0-9]+)(,(?<column>[0-9]+))?] error: (?<message>.+)")
));
groups.add(new Group("compile", "Compilation", "Compilation",
Pattern.compile("\\[ERROR] COMPILATION ERROR.*"),
Pattern.compile(".*location: +(.+)"),
Pattern.compile("(?<file>.+):(?<line>[0-9]+): error: (?<message>.+)")
));
inGroup = null;
currentElement = null;
tests = new ArrayList<>();
errors = new ArrayList<>();
}
public List<Element> getErrors() {
return errors;
}
public List<Element> getTests() {
return tests;
}
public void parse(List<String> log){
for(String line : log){
parseLine(line);
}
}
public void parse(String log){
String[] lines = log.split("\n");
parse(Arrays.asList(lines));
}
public void parseLine(String line){
for (Group group : groups) {
if (this.inGroup != null && !group.name.equals(this.inGroup)) {
continue;
}
if (this.inGroup == null) {
LogMatcher matcher = new LogMatcher(group.start.matcher(line));
if (matcher.matches()) {
this.inGroup = group.name;
if (group.type.equals("test")) {
this.currentElement = new Element()
.put("name", matcher.group("name"))
.put("class", matcher.group("class"))
.put("body", "")
.put("nbTest", 1)
.put("nbFailure", 0)
.put("nbError", 0)
.put("nbSkip", 0)
.put("time", 0f);
this.tests.add(this.currentElement);
}
return;
}
} else {
LogMatcher matcher = new LogMatcher(group.end.matcher(line));
if (matcher.matches()) {
if (this.currentElement != null && matcher.groupCount() > 0 && matcher.group("nbTest") != null) {
this.currentElement.put("nbTest", parseIntOrNull(matcher.group("nbTest")));
this.currentElement.put("nbFailure", parseIntOrNull(matcher.group("failure")));
this.currentElement.put("nbError", parseIntOrNull(matcher.group("error")));
this.currentElement.put("nbSkipped", parseIntOrNull(matcher.group("skipped")));
this.currentElement.put("time", parseFloatOrNull(matcher.group("time")));
}
return;
}
LogMatcher matcher2 = new LogMatcher(group.element.matcher(line));
if (matcher2.matches()) {
if (matcher2.group("allLine") != null) {
//void
} else {
Element output = new Element()
.put("type", group.type)
.put("file", matcher2.group("file"))
.put("line", parseIntOrNull(matcher2.group("line")))
.put("column", parseIntOrNull(matcher2.group("column")))
.put("message", matcher2.group("message"))
.put("id", matcher2.group("id"));
this.errors.add(output);
}
return;
}
}
}
for (Independent independent : independents) {
LogMatcher matcher = new LogMatcher(independent.element.matcher(line));
if(matcher.matches()){
Element output = new Element()
.put("type", independent.type)
.put("name", matcher.group("name"))
.put("status", matcher.group("status"))
.put("class", matcher.group("class"))
.put("nbTest", parseIntOrNull(matcher.group("nbTest")))
.put("failed", parseIntOrNull(matcher.group("failed")))
.put("skipped", parseIntOrNull(matcher.group("skipped")))
.put("message", matcher.group("message"))
.put("file", matcher.group("file"))
.put("line", parseIntOrNull(matcher.group("line")))
.put("column", parseIntOrNull(matcher.group("column")))
.put("group", matcher.group("group"))
.put("artifact", matcher.group("artifact"))
.put("version", matcher.group("version"))
.put("artifact", matcher.group("artifact"))
.put("rule", matcher.group("rule"))
.put("priority", matcher.group("priority"))
.put("failure", matcher.group("failure"))
.put("error", parseIntOrNull(matcher.group("error")))
.put("time", parseFloatOrNull(matcher.group("time")));
if(independent.type.equals("test")){
output.remove("type");
if(output.get("status") != null){
//log
}
if(output.get("nbTest") == null){
output.put("nbTest", 1);
}
this.tests.add(output);
} else {
this.errors.add(output);
}
return;
}
}
}
Integer parseIntOrNull(String s){
if(s == null) return null;
return Integer.parseInt(s);
}
Float parseFloatOrNull(String s){
if(s == null) return null;
return Float.parseFloat(s);
}
class Independent {
Pattern element;
String type;
String failureGroup;
Independent(Pattern element, String type, String failureGroup){
this.element = element;
this.type = type;
this.failureGroup = failureGroup;
}
}
class Group {
String name;
String type;
String failureGroup;
Pattern start;
Pattern end;
Pattern element;
Group(String name, String type, String failureGroup, Pattern start, Pattern end, Pattern element){
this.name = name;
this.type = type;
this.failureGroup = failureGroup;
this.start = start;
this.end = end;
this.element = element;
}
}
class LogMatcher {
Matcher matcher;
LogMatcher(Matcher m){
this.matcher = m;
}
String group(String name){
try{
return matcher.group(name);
} catch (IllegalArgumentException e){
return null;
}
}
int groupCount(){
return matcher.groupCount();
}
Boolean matches(){
return matcher.matches();
}
}
}
```
|
```package fr.inria.spirals.repairnator.buildrainer;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.util.Date;
public class BuildRainerTest {
@Test
/**
* This test if BuildRainer can connect
* and communicate with a ws server
* Remove ignore to test, this can be a bit flaky.
*/
public void testWebSocket()
{
TestServer testServer = TestServer.getInstance();
testServer.setReuseAddr(true);
testServer.run();
String receivedMsg = testServer.getBuildRainer().getRecentMessage();
assertEquals(receivedMsg,"Test");
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.buildrainer;
import fr.inria.spirals.repairnator.TravisInputBuild;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.InputBuild;
import java.net.URI;
import java.net.URISyntaxException;
import com.martiansoftware.jsap.JSAP;
import com.martiansoftware.jsap.JSAPException;
import com.martiansoftware.jsap.JSAPResult;
import com.martiansoftware.jsap.FlaggedOption;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.json.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;
/**
* This is a websocket, intended for listening to "tdurieux/travis-listener"
* to fetch most recent builds from Travis in realtime.
*/
public class BuildRainer extends WebSocketClient implements BuildSubmitter{
private static Logger LOGGER = LoggerFactory.getLogger(BuildRainer.class);
private static final BuildSubmitter submitter = new ActiveMQBuildSubmitter();
private static final RepairnatorConfig config = RepairnatorConfig.getInstance();
private static BuildRainer buildRainer;
private String recentMessage;
private static JSAP defineArgs() throws JSAPException{
JSAP jsap = new JSAP();
return jsap;
}
public BuildRainer( URI serverURI ) {
super( serverURI );
}
public String getRecentMessage() {
return recentMessage;
}
public boolean isJSONValid(String test) {
try {
new JSONObject(test);
} catch (JSONException ex) {
try {
new JSONArray(test);
} catch (JSONException ex1) {
return false;
}
}
return true;
}
@Override
public void onMessage( String message ) {
if (isJSONValid(message)) {
JSONObject obj = null;
try {
obj = new JSONObject(message);
} catch (JSONException e) {
e.printStackTrace();
}
String state = null;
try {
state = obj.getJSONObject("data").getString("state");
} catch (JSONException e) {
e.printStackTrace();
}
String language = null;
try {
language = obj.getJSONObject("data").getJSONObject("config").getString("language");
} catch (JSONException e) {
e.printStackTrace();
}
if (state.equals("failed") && language.equals("java")) {
LOGGER.info("state: " + state + " language: " + language);
int build_id = 0;
try {
build_id = obj.getJSONObject("data").getInt("build_id");
} catch (JSONException e) {
e.printStackTrace();
}
this.submitBuild(new TravisInputBuild(build_id));
}
}
this.recentMessage = message;
}
public static BuildRainer getInstance() {
LOGGER.warn("Build Rainer is now running");
if (buildRainer == null) {
try {
((ActiveMQBuildSubmitter) submitter).initBroker();
buildRainer = new BuildRainer( new URI( config.getWebSocketUrl() ));
} catch(URISyntaxException e) {
throw new RuntimeException("Invalid websocket URI");
}
}
return buildRainer;
}
@Override
public void submitBuild(InputBuild b) {
submitter.submitBuild(b);
}
@Override
public void onOpen( ServerHandshake handshakedata ) {
LOGGER.warn( "opened connection" );
}
@Override
public void onClose( int code, String reason, boolean remote ) {
LOGGER.warn( "Connection closed by " + ( remote ? "remote peer" : "us" ) + " Code: " + code + " Reason: " + reason );
}
@Override
public void onError( Exception ex ) {
ex.printStackTrace();
}
}
```
|
```package fr.inria.spirals.repairnator.pipeline;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.step.AbstractStep;
import org.junit.After;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import static org.junit.Assert.*;
/**
* Dear maintainer, the CI on Travis might fail or process this test too late because the information of the test
* results stops existing after an amount of time. If this happens go to repainator/failinProject repository and
* rerun the jobs of the commits used below. For this you need the autorization of repairnator Github organization,
* so just ask @monperrus for this and you will have the power to do this.
* Last time jobs where run: 2023-01-13 by @Sofi1410
*/
public class TestPipelineSequencerRepair {
@Rule
public TemporaryFolder workspaceFolder = new TemporaryFolder();
@Rule
public TemporaryFolder outputFolder = new TemporaryFolder();
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
}
@Test
@Ignore
//FIXME: We can't rely on repairnator/failing project to get builds
public void TestPipelineSequencerRepairTool() throws Exception {
// ec915681fbd6a8b2c30580b2618e62636204abe4 -> repairnator/failingProject -> syntax
Launcher launcher = new Launcher(new String[]{
"--sequencerRepair",
"--gitrepourl", "https://github.com/repairnator/failingProject",
"--gitrepoidcommit", "ec915681fbd6a8b2c30580b2618e62636204abe4",
"--launcherMode", "SEQUENCER_REPAIR",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
// config is forced to use SequencerRepair as the only repair tool.
assertEquals(1, launcher.getConfig().getRepairTools().size());
assertTrue(launcher.getConfig().getRepairTools().contains("SequencerRepair"));
launcher.mainProcess();
List<AbstractStep> steps = launcher.getInspector().getSteps()
.stream()
.filter(step -> step.getName().equals("SequencerRepair"))
.collect(Collectors.toList()); //test fix sequencer repair
assertEquals(2, steps.size());
}
@Test
@Ignore
//FIXME: We can't rely on repairnator/failing project to get builds
public void TestPipelineBuildPassBranch() throws Exception{
// e182ccb9ef41b5adab602ed12bfc71b744ff0241 -> repairnator/failingProject -> nofixes
Launcher launcher = new Launcher(new String[]{
"--sequencerRepair",
"--gitrepourl", "https://github.com/repairnator/failingProject",
"--gitrepoidcommit", "e182ccb9ef41b5adab602ed12bfc71b744ff0241",
"--launcherMode", "SEQUENCER_REPAIR",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
launcher.mainProcess();
AbstractStep step = launcher.getInspector().getSteps().get(4); //test fix sequencer repair
assertNotNull(step.getStepStatus());
}
@Test
@Ignore
//FIXME: We can't rely on repairnator/failing project to get builds
public void TestPipelineBuildFailBranch() throws Exception{
// ec915681fbd6a8b2c30580b2618e62636204abe4 -> repairnator/failingProject -> syntax error
Launcher launcher = new Launcher(new String[]{
"--gitrepourl", "https://github.com/repairnator/failingProject",
"--gitrepoidcommit", "ec915681fbd6a8b2c30580b2618e62636204abe4",
"--sequencerRepair",
"--launcherMode", "SEQUENCER_REPAIR",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
launcher.mainProcess();
AbstractStep step = launcher.getInspector().getSteps().get(9); //syntax fix sequencer repair
assertNotNull(step.getStepStatus());
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.repair.sequencer;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.spotify.docker.client.DockerClient;
import com.spotify.docker.client.messages.*;
import fr.inria.spirals.repairnator.config.SequencerConfig;
import fr.inria.spirals.repairnator.docker.DockerHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.RepairPatch;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.repair.AbstractRepairStep;
import fr.inria.spirals.repairnator.process.step.repair.sequencer.detection.AstorDetectionStrategy;
import fr.inria.spirals.repairnator.process.step.repair.sequencer.detection.DetectionStrategy;
import fr.inria.spirals.repairnator.process.step.repair.sequencer.detection.ModificationPoint;
import org.apache.commons.io.IOUtils;
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* SequencerRepair is one builtin repair tool. It generates
* patches by invoking SequenceR docker image.
*
* SequencerRepair is dependent on Astor as it collects info
* about suspicious modification locations from the latter
* to feed SequenceR.
*
* SequenceR is one seq2seq model designed to predict source
* code change on line level. Check its paper for more info:
* https://arxiv.org/abs/1901.01808
*
* @author Jian GU
* @author Javier Ron
*/
public class SequencerRepair extends AbstractRepairStep {
public static final String TOOL_NAME = "SequencerRepair";
private final SequencerConfig config;
private final DockerClient docker;
private DetectionStrategy detectionStrategy;
public SequencerRepair(){
this.config = SequencerConfig.getInstance();
this.docker = DockerHelper.initDockerClient();
this.detectionStrategy = new AstorDetectionStrategy();
}
public SequencerRepair(DetectionStrategy detectionStrategy){
this.config = SequencerConfig.getInstance();
this.docker = DockerHelper.initDockerClient();
this.detectionStrategy = detectionStrategy;
}
@Override
public String getRepairToolName() {
return TOOL_NAME;
}
@Override
protected StepStatus businessExecute() {
this.getLogger().info("Start SequencerRepair");
String pathPrefix = ""; // for macOS: "/private";
JobStatus jobStatus = this.getInspector().getJobStatus();
Path patchDir = Paths.get(pathPrefix + this.getInspector().getRepoLocalPath() +
"/repairnator." + TOOL_NAME + ".results");
try {
Files.createDirectory(patchDir);
} catch (IOException e) {
addStepError("Got exception when running SequencerRepair: ", e);
}
// check ...
List<URL> classPath = this.getInspector().getJobStatus().getRepairClassPath();
File[] sources = this.getInspector().getJobStatus().getRepairSourceDir();
if (classPath == null || sources == null) {
return StepStatus.buildSkipped(this,"Classpath or Sources not computed.");
}
detectionStrategy.setup(getInspector(), getPom(), getLogger());
List<ModificationPoint> suspiciousPoints = detectionStrategy.detect(this);
if(suspiciousPoints.isEmpty()){
return StepStatus.buildPatchNotFound(this);
}
/// pull Sequencer if image not present
try {
List<Image> images = docker.listImages(DockerClient.ListImagesParam.byName(config.dockerTag));
if(images.size() <= 0) docker.pull(config.dockerTag);
} catch (Exception e) {
return StepStatus.buildSkipped(this,"Error while retrieving sequencer docker image: " + e);
}
final ExecutorService executor = Executors.newFixedThreadPool(config.threads);
List<Future<SequencerResult>> allResults = new ArrayList<>();
suspiciousPoints.forEach( smp -> allResults.add(executor.submit(() -> {
try {
int smpId = smp.hashCode();
Path suspiciousFile = smp.getFilePath().toRealPath();
Path buggyFilePath = suspiciousFile.toAbsolutePath();
Path buggyParentPath = suspiciousFile.getParent();
Path repoPath = Paths.get(getInspector().getRepoLocalPath()).toRealPath();
Path relativePath = repoPath.relativize(suspiciousFile);
int buggyLineNumber = smp.getSuspiciousLine();
int beamSize = config.beamSize;
String buggyFileName = suspiciousFile.getFileName().toString();
Path outputDirPath = patchDir.toAbsolutePath().resolve(buggyFileName + smpId);
if ( !Files.exists(outputDirPath) || !Files.isDirectory(outputDirPath)) {
Files.createDirectory(outputDirPath);
outputDirPath = outputDirPath.toRealPath();
}
String sequencerCommand = "./sequencer-predict.sh "
+ "--buggy_file=" + "/tmp/" + buggyFileName + " "
+ "--buggy_line=" + buggyLineNumber + " "
+ "--beam_size=" + beamSize + " "
+ "--real_file_path=" + relativePath + " "
+ "--output=" + "/out" + " "
+ "--models_dir=" + "/root/sequencer/models";
HostConfig.Builder hostConfigBuilder = HostConfig.builder();
/*
* note: the following code block provides a way to
* mount directories from one docker container
* into a sibling container.
*
* Otherwise, the docker daemon will try to mount from its own filesystem.
*
* This solution may be _too_ ad hoc.
*/
String parentPathStr = buggyParentPath.toString();
String outputPathStr = outputDirPath.toString();
if( Files.exists(Paths.get("/.dockerenv"))){
ProcessBuilder processBuilder = new ProcessBuilder();
processBuilder.command("bash", "-c", "basename `cat /proc/1/cpuset`");
Process proc = processBuilder.start();
StringWriter writer = new StringWriter();
IOUtils.copy(proc.getInputStream(), writer);
String containerId = writer.toString().trim();
ContainerInfo info = docker.inspectContainer(containerId);
String workspaceDir = Paths.get(getInspector().getWorkspace()).toRealPath().toString();
String mountPointSrt = info.mounts().stream()
.filter(item -> item.destination().equals(workspaceDir))
.findFirst().get().source();
parentPathStr = parentPathStr.replaceFirst(workspaceDir, mountPointSrt);
outputPathStr = outputPathStr.replaceFirst(workspaceDir, mountPointSrt);
}
hostConfigBuilder
.appendBinds(HostConfig.Bind
.from(parentPathStr)
.to("/tmp")
.build())
.appendBinds(HostConfig.Bind
.from(outputPathStr)
.to("/out")
.build());
HostConfig hostConfig = hostConfigBuilder.build();
ContainerConfig containerConfig = ContainerConfig.builder()
.image(config.dockerTag)
.hostConfig(hostConfig)
.cmd("bash", "-c", sequencerCommand)
.attachStdout(true)
.attachStderr(true)
.build();
ContainerCreation container = docker.createContainer(containerConfig);
docker.startContainer(container.id());
docker.waitContainer(container.id());
String stdOut = docker.logs(
container.id(),
DockerClient.LogsParam.stdout()
).readFully();
String stdErr = docker.logs(
container.id(),
DockerClient.LogsParam.stderr()
).readFully();
docker.removeContainer(container.id());
this.getLogger().debug("stdOut: \n" + stdOut);
this.getLogger().debug("stdErr: \n" + stdErr);
return new SequencerResult(buggyFilePath.toString(), outputDirPath.toString(),
stdOut, stdErr);
} catch (Throwable throwable) {
addStepError("Got exception when running SequencerRepair: ", throwable);
return null;
}
})));
List<SequencerResult> sequencerResults = new ArrayList<>();
try {
executor.shutdown();
executor.awaitTermination(config.timeout, TimeUnit.MINUTES);
for (Future<SequencerResult> result : allResults){
sequencerResults.add(result.get());
}
} catch (Exception e) {
addStepError("Got exception when running SequencerRepair: ", e);
}
/// prepare results
List<RepairPatch> listPatches = new ArrayList<>();
JsonArray toolDiagnostic = new JsonArray();
listPatches = sequencerResults.stream().flatMap( result -> {
JsonObject diagnostic = new JsonObject();
diagnostic.addProperty("success", result.isSuccess());
diagnostic.addProperty("message", result.getMessage());
diagnostic.addProperty("warning", result.getWarning());
toolDiagnostic.add(diagnostic);
List<String> diffs = result.getDiffs();
diffs.stream().forEach(d -> System.out.println(d));
Stream<RepairPatch> patches = diffs.stream()
.map(diff -> new RepairPatch(this.getRepairToolName(), result.getBuggyFilePath(), diff))
.filter(detectionStrategy::validate);
return patches;
}).collect(Collectors.toList());
List<RepairPatch> analyzedPatches = this.performPatchAnalysis(listPatches);
if (analyzedPatches.isEmpty()) {
return StepStatus.buildPatchNotFound(this);
}
this.recordPatches(analyzedPatches, MAX_PATCH_PER_TOOL);
this.recordToolDiagnostic(toolDiagnostic);
try {
Files.walk(patchDir)
.sorted(Comparator.reverseOrder())
.map(Path::toFile)
.forEach(File::delete);
} catch (IOException e) {
addStepError("Got exception when running SequencerRepair: ", e);
}
jobStatus.setHasBeenPatched(true);
return StepStatus.buildSuccess(this);
}
}
```
|
```package fr.inria.spirals.repairnator.process.step.push;
import ch.qos.logback.classic.Level;
import fr.inria.jtravis.entities.Build;
import fr.inria.spirals.repairnator.BuildToBeInspected;
import fr.inria.spirals.repairnator.utils.Utils;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.process.files.FileHelper;
import fr.inria.spirals.repairnator.process.inspectors.JobStatus;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.CloneRepository;
import fr.inria.spirals.repairnator.process.step.checkoutrepository.CheckoutBuggyBuild;
import fr.inria.spirals.repairnator.process.utils4tests.ProjectInspectorMocker;
import fr.inria.spirals.repairnator.states.PushState;
import fr.inria.spirals.repairnator.states.ScannedBuildStatus;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.revwalk.RevCommit;
import org.hamcrest.core.Is;
import org.hamcrest.core.IsNull;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;
/**
* Created by urli on 27/04/2017.
*/
public class TestInitRepoToPush {
private File tmpDir;
@Before
public void setup() {
Utils.setLoggersLevel(Level.INFO);
RepairnatorConfig config = RepairnatorConfig.getInstance();
config.setGithubUserEmail("noreply@github.com");
config.setGithubUserName("repairnator");
config.setJTravisEndpoint("https://api.travis-ci.com");
}
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
FileHelper.deleteFile(tmpDir);
}
@Test
@Ignore("This test uses repairnator/failingProject build, which is not available anymore.")
public void testInitRepoToPushSimpleCase() throws IOException, GitAPIException {
long buildId = 220946365; // repairnator/failingProject build
RepairnatorConfig repairnatorConfig = RepairnatorConfig.getInstance();
repairnatorConfig.setClean(false);
repairnatorConfig.setPush(true);
Build build = this.checkBuildAndReturn(buildId, false);
tmpDir = Files.createTempDirectory("test_initRepoToPush").toFile();
BuildToBeInspected toBeInspected = new BuildToBeInspected(build, null, ScannedBuildStatus.ONLY_FAIL, "");
JobStatus jobStatus = new JobStatus(tmpDir.getAbsolutePath()+"/repo");
jobStatus.getProperties().getBuilds().setBuggyBuild(new fr.inria.spirals.repairnator.process.inspectors.properties.builds.Build(buildId, "", new Date()));
ProjectInspector inspector = ProjectInspectorMocker.mockProjectInspector(jobStatus, tmpDir, toBeInspected);
CloneRepository cloneStep = new CloneRepository(inspector);
cloneStep.addNextStep(new CheckoutBuggyBuild(inspector, true)).addNextStep(new InitRepoToPush(inspector));
cloneStep.execute();
assertTrue(jobStatus.getPushStates().contains(PushState.REPO_INITIALIZED));
Git gitDir = Git.open(new File(tmpDir, "repotopush"));
Iterable<RevCommit> logs = gitDir.log().call();
Iterator<RevCommit> iterator = logs.iterator();
assertTrue(iterator.hasNext());
RevCommit commit = iterator.next();
assertTrue(commit.getShortMessage().contains("Bug commit"));
assertFalse(iterator.hasNext());
}
private Build checkBuildAndReturn(long buildId, boolean isPR) {
Optional<Build> optionalBuild = RepairnatorConfig.getInstance().getJTravis().build().fromId(buildId);
assertTrue(optionalBuild.isPresent());
Build build = optionalBuild.get();
assertThat(build, IsNull.notNullValue());
assertThat(buildId, Is.is(build.getId()));
assertThat(build.isPullRequest(), Is.is(isPR));
return build;
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.push;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.states.PushState;
/**
* Created by urli on 26/04/2017.
*/
public class InitRepoToPush extends CommitFiles {
public InitRepoToPush(ProjectInspector inspector) {
super(inspector);
}
@Override
protected StepStatus businessExecute() {
if (this.getConfig().isPush()) {
this.getLogger().info("Repairnator is configured to push. Init local repo to push and commit buggy build...");
super.setCommitType(CommitType.COMMIT_BUGGY_BUILD);
StepStatus stepStatus = super.businessExecute();
if (stepStatus.isSuccess()) {
this.setPushState(PushState.REPO_INITIALIZED);
} else {
this.setPushState(PushState.REPO_NOT_INITIALIZED);
}
return stepStatus;
} else {
this.getLogger().info("Repairnator is configured NOT to push. Step bypassed.");
return StepStatus.buildSkipped(this);
}
}
}
```
|
```package fr.inria.spirals.repairnator.realtime.utils;
import static org.junit.Assert.assertEquals;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.junit.Test;
import org.kohsuke.github.*;
public class PatchFilterTest {
String testRepoSlug = "javierron/continuous-sequencer-test";
@Test
public void testSingleLineCommit() throws IOException {
PatchFilter filter = new PatchFilter();
//TODO: should use the credentials stored in Jenkins.
GitHub github = GitHub.connect(null, System.getenv("GITHUB_OAUTH"));
GHRepository repo;
GHCommit commit;
boolean filterMultiFile = true;
boolean filterMultiHunk = true;
repo = github.getRepository(testRepoSlug);
commit = repo.getCommit("918b862a1e722a67337cf9f2a6485692efc23602");
int hunkDistance = 0;
Map<String, String> rawFilesMap = new HashMap<>();
ArrayList<SequencerCollectorPatch> patches = filter.getCommitPatches(commit, filterMultiFile, 3, rawFilesMap, repo);
ArrayList<SequencerCollectorHunk> hunks = filter.getHunks(patches, filterMultiHunk, hunkDistance);
assertEquals(1, hunks.size());
}
@Test
public void testSingleLineCommitNonMatching() throws IOException {
PatchFilter filter = new PatchFilter();
GitHub github = GitHub.connect(null, System.getenv("GITHUB_OAUTH"));
GHRepository repo;
GHCommit commit;
boolean filterMultiFile = true;
boolean filterMultiHunk = true;
repo = github.getRepository(testRepoSlug);
commit = repo.getCommit("14e4672ea8de7dbdc63b41b8ec9334c936ab515a");
int hunkDistance = 0;
Map<String, String> rawFilesMap = new HashMap<>();
ArrayList<SequencerCollectorPatch> patches = filter.getCommitPatches(commit, filterMultiFile, 3, rawFilesMap, repo);
ArrayList<SequencerCollectorHunk> hunks = filter.getHunks(patches, filterMultiHunk, hunkDistance);
assertEquals(0, hunks.size());
}
@Test
public void testMultipleFilesSingleLineChanges() throws IOException {
PatchFilter filter = new PatchFilter();
GitHub github = GitHub.connect(null, System.getenv("GITHUB_OAUTH"));
GHRepository repo;
GHCommit commit;
boolean filterMultiFile = false;
boolean filterMultiHunk = true;
repo = github.getRepository(testRepoSlug);
commit = repo.getCommit("14e4672ea8de7dbdc63b41b8ec9334c936ab515a");
int hunkDistance = 0;
Map<String, String> rawFilesMap = new HashMap<>();
ArrayList<SequencerCollectorPatch> patches = filter.getCommitPatches(commit, filterMultiFile, 3, rawFilesMap, repo);
ArrayList<SequencerCollectorHunk> hunks = filter.getHunks(patches, filterMultiHunk, hunkDistance);
assertEquals(3, hunks.size());
}
@Test
public void testSingleFileMultiHunkChanges() throws IOException {
PatchFilter filter = new PatchFilter();
GitHub github = GitHub.connect(null, System.getenv("GITHUB_OAUTH"));
GHRepository repo;
GHCommit commit;
boolean filterMultiFile = true;
boolean filterMultiHunk = false;
repo = github.getRepository(testRepoSlug);
commit = repo.getCommit("a3f4a35c980735e933a60f35eb7a2c243a28396c");
int hunkDistance = 0;
Map<String, String> rawFilesMap = new HashMap<>();
ArrayList<SequencerCollectorPatch> patches = filter.getCommitPatches(commit, filterMultiFile, 3, rawFilesMap, repo);
ArrayList<SequencerCollectorHunk> hunks = filter.getHunks(patches, filterMultiHunk, hunkDistance);
assertEquals(3, hunks.size());
}
@Test
public void testMultipleFileMultiHunkChanges() throws IOException {
PatchFilter filter = new PatchFilter();
GitHub github = GitHub.connect(null, System.getenv("GITHUB_OAUTH"));
GHRepository repo;
GHCommit commit;
boolean filterMultiFile = false;
boolean filterMultiHunk = false;
repo = github.getRepository(testRepoSlug);
commit = repo.getCommit("eabbfae4049ec34e04720c31d9c17d203834ec17");
int hunkDistance = 0;
Map<String, String> rawFilesMap = new HashMap<>();
ArrayList<SequencerCollectorPatch> patches = filter.getCommitPatches(commit, filterMultiFile, 3, rawFilesMap, repo);
ArrayList<SequencerCollectorHunk> hunks = filter.getHunks(patches, filterMultiHunk, hunkDistance);
assertEquals(10, hunks.size());
}
@Test
public void testMultipleFileMultiHunkChangesNonMatching() throws IOException {
PatchFilter filter = new PatchFilter();
GitHub github = GitHub.connect(null, System.getenv("GITHUB_OAUTH"));
GHRepository repo;
GHCommit commit;
boolean filterMultiFile = false;
boolean filterMultiHunk = false;
repo = github.getRepository(testRepoSlug);
commit = repo.getCommit("309fcf66423785546ec8c1d84853cb18f508ad0a");
int hunkDistance = 0;
Map<String, String> rawFilesMap = new HashMap<>();
ArrayList<SequencerCollectorPatch> patches = filter.getCommitPatches(commit, filterMultiFile, 3, rawFilesMap, repo);
ArrayList<SequencerCollectorHunk> hunks = filter.getHunks(patches, filterMultiHunk, hunkDistance);
assertEquals(0, hunks.size());
}
@Test
public void testContextSize() throws IOException {
PatchFilter filter = new PatchFilter();
GitHub github = GitHub.connect(null, System.getenv("GITHUB_OAUTH"));
GHRepository repo;
GHCommit commit;
boolean filterMultiFile = false;
boolean filterMultiHunk = false;
repo = github.getRepository("java-diff-utils/java-diff-utils");
commit = repo.getCommit("de04bd688a0ee067fbe9bbc6344b1ceedfd6e220");
int hunkDistance = 0;
Map<String, String> rawFilesMap = new HashMap<>();
ArrayList<SequencerCollectorPatch> patches = filter.getCommitPatches(commit, filterMultiFile, 3, rawFilesMap, repo);
ArrayList<SequencerCollectorHunk> hunks = filter.getHunks(patches, filterMultiHunk, hunkDistance);
assertEquals(3, hunks.size());
ArrayList<SequencerCollectorPatch> patches25 = filter.getCommitPatches(commit, filterMultiFile, 25, rawFilesMap, repo);
ArrayList<SequencerCollectorHunk> hunks25 = filter.getHunks(patches25, filterMultiHunk, hunkDistance);
assertEquals(1, hunks25.size());
ArrayList<SequencerCollectorPatch> patches200 = filter.getCommitPatches(commit, filterMultiFile, 200, rawFilesMap, repo);
ArrayList<SequencerCollectorHunk> hunks200 = filter.getHunks(patches200, filterMultiHunk, hunkDistance);
assertEquals(0, hunks200.size());
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.realtime.utils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.net.*;
import java.util.stream.Collectors;
import com.github.difflib.DiffUtils;
import com.github.difflib.UnifiedDiffUtils;
import com.github.difflib.patch.Patch;
import org.apache.commons.io.IOUtils;
import org.kohsuke.github.GHCommit;
import org.kohsuke.github.GHContent;
import org.kohsuke.github.GHRepository;
/**
* Single-line-change filter.
* */
public class PatchFilter {
static final String HUNK_HEADER_REGEX = "^@@ -(\\d+),(\\d+) \\+(\\d+),(\\d+) @@ ?.*$";
static final String SPLIT_BY_HUNKS_REGEX = "(?<=\\n)(?=@@ -\\d+,\\d+ \\+\\d+,\\d+ @@ ?.*\\n)";
enum State {
ENTRY,
HEADER,
ENTRY_CONTEXT,
EXIT_CONTEXT,
REMOVE,
ADD
}
public class HunkLines {
public HunkLines(String removed, String added) {
this.removed = removed;
this.added = added;
}
public final String removed;
public final String added;
}
String[] splitByLines(String hunk) {
return hunk.split("\n");
}
boolean isRegularHunkHeader(String hunkHeader) {
Pattern p = Pattern.compile(HUNK_HEADER_REGEX);
Matcher m = p.matcher(hunkHeader);
if(m.find()) {
if(m.group(1).equals(m.group(3)) && m.group(2).equals(m.group(4))) {
return true;
}
}
return false;
}
int getHunkLine(String hunkHeader) {
Pattern p = Pattern.compile(HUNK_HEADER_REGEX);
Matcher m = p.matcher(hunkHeader);
if(m.find()) {
return Integer.parseInt(m.group(3));
}
return -1;
}
boolean test(String[] hunkLines) {
State state = State.ENTRY;
for(String line : hunkLines) {
switch(state) {
//assuming first line is hunk header.
case ENTRY:{
state = State.HEADER;
break;
}
case HEADER:{
char first = line.charAt(0);
if(first == '-') {
state = State.REMOVE;
} else if(first == ' ') {
state = State.ENTRY_CONTEXT;
} else if(first == '+') {
return false;
}
}break;
case ENTRY_CONTEXT:{
char first = line.charAt(0);
if(first == '-') {
state = State.REMOVE;
} else if(first == ' ') {
state = State.ENTRY_CONTEXT;
} else {
return false;
}
}break;
case REMOVE:{
char first = line.charAt(0);
if(first == '+') {
state = State.ADD;
}else{
return false;
}
}break;
case ADD:
case EXIT_CONTEXT: {
char first = line.charAt(0);
if(first == ' ') {
state = State.EXIT_CONTEXT;
}else{
return false;
}
}break;
}
}
return state == State.EXIT_CONTEXT || state == State.ADD;
}
public ArrayList<SequencerCollectorHunk> getHunks(ArrayList<SequencerCollectorPatch> patches, boolean singleHunk, int hunkDistance){
ArrayList<SequencerCollectorHunk> ret = new ArrayList<>();
for(SequencerCollectorPatch patch : patches) {
String[] split = patch.getContent().split(SPLIT_BY_HUNKS_REGEX);
String[] hunks = Arrays.copyOfRange(split, 1, split.length); //drop file header
ArrayList<Boolean> oneLineHunks = new ArrayList<>();
ArrayList<Integer> linePositions = new ArrayList<>();
if(singleHunk && hunks.length != 1) continue;
for(String hunk: hunks) {
String[] lines = splitByLines(hunk);
linePositions.add(getHunkLine(lines[0]));
oneLineHunks.add(isRegularHunkHeader(lines[0]) && test(lines));
}
for(int i = 0; i < oneLineHunks.size() - 1; ++i) {
boolean isFarEnough = oneLineHunks.get(i) && ( linePositions.get(i + 1) - linePositions.get(i) > hunkDistance);
oneLineHunks.set(i, isFarEnough);
}
for(int i = oneLineHunks.size() - 1; i > 0; --i) {
boolean isFarEnough = oneLineHunks.get(i) && ( linePositions.get(i) - linePositions.get(i - 1) > hunkDistance);
oneLineHunks.set(i, isFarEnough);
}
for(int i = 0; i < oneLineHunks.size(); ++i) {
if(oneLineHunks.get(i)){
ret.add( new SequencerCollectorHunk(linePositions.get(i), patch.getFile(), hunks[i]));
}
}
}
return ret;
}
/**
* Returns a list of patches.
*
* if filterMultiFile is true, it will filter out multi-file commits
* */
public ArrayList<SequencerCollectorPatch>
getCommitPatches(GHCommit commit, boolean filterMultiFile, int contextSize, Map<String, String> rawFilesStore, GHRepository repo ) throws IOException{
ArrayList<SequencerCollectorPatch> ret = new ArrayList<>();
List<GHCommit.File> javaFiles = commit
.getFiles().stream()
.filter(file -> file.getFileName().endsWith(".java"))
.filter(file -> file.getLinesAdded() != 0) //filter deletion only changes
.filter(file -> file.getLinesDeleted() != 0) // filter addition only changes
.collect(Collectors.toList());
if(filterMultiFile && javaFiles.size() != 1) {
return ret;
}
javaFiles.forEach(f -> {
if(f.getPatch() != null) { //sometimes this call returns null
String fullFilename = f.getFileName();
try {
// don't use github client since we may need to change target urls
// to a mirror in case rate limits are exceeded
// read from url, //raw.githubusercontent.com/{owner}/{repo}/{sha}/{path}
String fileURL = RawURLGenerator.Generate(commit.getOwner().getFullName(), commit.getSHA1(), fullFilename);
// read from url, //raw.githubusercontent.com/{owner}/{repo}/{parent_sha}/{path}
String parentFilename = fullFilename;
String previousFilename = f.getPreviousFilename();
//if name change occurred -> get correct parent file
if(previousFilename != null && !previousFilename.isEmpty() && !previousFilename.equals(fullFilename)){
parentFilename = previousFilename;
}
String changesCommit=commit.getParents().get(0).getSHA1();
String pastCommit=commit.getSHA1();
String filePath=parentFilename;
String changes = readFileFromRepo(repo,filePath,changesCommit);
String past =readFileFromRepo(repo,filePath,pastCommit);
rawFilesStore.put(fullFilename, past);
List<String> changesAsList = Arrays.asList(changes.split("\n").clone());
List<String> pastAsList = Arrays.asList(past.split("\n").clone());
Patch<String> diff = DiffUtils.diff(pastAsList, changesAsList);
List<String> uDiff = UnifiedDiffUtils.generateUnifiedDiff(fullFilename, fullFilename, pastAsList, diff, contextSize);
String patch = String.join("\n", uDiff);
ret.add( new SequencerCollectorPatch(fullFilename, patch));
}catch(Exception e){
System.out.println("Exception while getting raw files, skipping patch: " + e);
}
}
});
return ret;
}
/**
* Method to get a file from a GitHub repository using its URL path
* @param ref commit of reference
* @param path path of the file in the repo
* @param repo repository
* @return the data in the file as plain text
*/
String readFileFromRepo(GHRepository repo,String path, String ref){
String data;
try {
GHContent gChanges=repo.getFileContent(path,ref);
data= gChanges.getContent();
}catch (Exception e){
throw new RuntimeException("Error while reading file from URL:" + path + " -- type: " + e.getClass().getName() +" --message "+e.getMessage()+" --cause "+ e.getCause().toString());
}
return data;
}
}
```
|
```package fr.inria.spirals.repairnator.realtime;
import fr.inria.jtravis.entities.Build;
import fr.inria.jtravis.entities.Commit;
import fr.inria.jtravis.entities.v2.BuildV2;
import fr.inria.spirals.repairnator.InputBuild;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.realtime.githubapi.commits.models.SelectedCommit;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.*;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import static org.junit.Assert.*;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.*;
public class TestZeroScanner {
@Mock
DockerPipelineRunner runner;
@Mock
SequencerCollector collector;
@Spy
@InjectMocks
ZeroScanner scanner = new ZeroScanner();
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
ZeroScanner.setup();
}
@After
public void cleanup(){
//config singleton is not reset between tests and
//this setting causes some interference
RepairnatorConfig.getInstance().setDockerImageName(null);
}
@Test
public void TestAttemptJob () {
SelectedCommit commit = new SelectedCommit(true, "javierron/failingProject", "65eb0ee8cc221bd4fe6d6414feb6ee368131288d");
scanner.attemptJob(commit); //failing job
verify(runner, times(1)).submitBuild(any(InputBuild.class));
}
@Test
public void TestCollectJob () {
SelectedCommit commit = new SelectedCommit(false, "javierron/failingProject", "bc7c358653159be5caece027258b822e47dc894c");
scanner.collectJob(commit); //passing job
verify(collector, times(1)).handle(anyString(), anyString());
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.realtime;
import fr.inria.spirals.repairnator.GithubInputBuild;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.config.SequencerConfig;
import fr.inria.spirals.repairnator.realtime.githubapi.commits.models.SelectedCommit;
import fr.inria.spirals.repairnator.states.LauncherMode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.*;
/**
* Scanner based on FastScanner.java and SequencerLearnerScanner.java
* The purpose is to both collect one-line changes from passing builds
* and try to repair failing builds.
*
* @author Javier Ron
*/
public class ZeroScanner implements Runnable {
private static final Logger LOGGER = LoggerFactory.getLogger(ZeroScanner.class);
private GithubScanner scanner;
private SequencerCollector collector;
private DockerPipelineRunner runner;
private Set<String> collected = new HashSet<>();
private Set<String> attempted = new HashSet<>();
public static void main(String[] args) {
setup();
ZeroScanner scanner = new ZeroScanner();
scanner.run();
}
static void setup(){
//Setup repairnator config
//repair tools
HashSet<String> repairTools = new HashSet<>();
repairTools.add("SequencerRepair");
RepairnatorConfig.getInstance().setRepairTools(repairTools);
//concurrent repair job
RepairnatorConfig.getInstance().setNbThreads(16);
//pipeline mode
RepairnatorConfig.getInstance().setPipelineMode(RepairnatorConfig.PIPELINE_MODE.DOCKER.name());
//github oauth
RepairnatorConfig.getInstance().setGithubToken(System.getenv("GITHUB_OAUTH"));
//pipeline image tag
RepairnatorConfig.getInstance().setDockerImageName("repairnator/pipeline:latest");
//launcher mode
RepairnatorConfig.getInstance().setLauncherMode(LauncherMode.SEQUENCER_REPAIR);
RepairnatorConfig.getInstance().setOutputPath("/tmp");
}
public ZeroScanner() {
this.scanner = new GithubScanner();
this.collector = new SequencerCollector(SequencerConfig.getInstance().contextSize);
this.runner = new DockerPipelineRunner(UUID.randomUUID().toString());
runner.initRunner();
}
@Override
public void run() {
LOGGER.info("Starting alpha scanner...");
try {
collector.initialize();
} catch (IOException e) {
throw new RuntimeException(e);
}
while (true) {
LOGGER.info("New scanning iteration");
try {
List<SelectedCommit> latestJobList = scanner.fetch(GithubScanner.FetchMode.ALL, null);
for (SelectedCommit job : latestJobList) {
LOGGER.debug("Scanning job: " + job.getRepoName() + " commit: " + job.getCommitId());
//switch (job.getGithubActionsFailed()) {
if (job.getGithubActionsFailed()) { // build failed
if (isListedJob(job, attempted)) {
LOGGER.debug("Job fix already attempted, skipping");
continue;
}
attemptJob(job);
} else { // build passed
if (isListedJob(job, collected)) {
LOGGER.debug("Job's changes already collected, skipping");
continue;
}
collectJob(job);
}
}
} catch (OutOfMemoryError oom){
LOGGER.error("Out of memory error: " + oom.toString());
runner.switchOff();
System.exit(-1);
} catch (Exception e) {
LOGGER.error("failed to get commit: " + e.toString());
}
} // end while loop
}
protected void collectJob(SelectedCommit job){
LOGGER.info("===== COLLECTING FOR DATA: " + job.getRepoName() + "-" + job.getCommitId());
collector.handle(job.getRepoName(), job.getCommitId());
collected.add(job.getRepoName() + "-" + job.getCommitId());
}
protected void attemptJob(SelectedCommit job){
LOGGER.info("===== ATTEMPT REPAIR: " + job.getRepoName() + "-" + job.getCommitId());
runner.submitBuild(new GithubInputBuild(job.getRepoName(), null, job.getCommitId()));
attempted.add(job.getRepoName() + "-" +job.getCommitId());
}
private boolean isListedJob(SelectedCommit job, Set<String> set){
return set.contains(job.getRepoName() + "-" + job.getCommitId());
}
}
```
|
```package fr.inria.spirals.repairnator.pipeline;
import com.google.common.annotations.VisibleForTesting;
import fr.inria.spirals.repairnator.config.RepairnatorConfig;
import fr.inria.spirals.repairnator.notifier.PatchNotifier;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.inspectors.RepairPatch;
import fr.inria.spirals.repairnator.process.step.AbstractStep;
import fr.inria.spirals.repairnator.states.LauncherMode;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.mockito.Mockito;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import static org.junit.Assert.*;
public class TestPipelineSoBoBot {
@Rule
public TemporaryFolder workspaceFolder = new TemporaryFolder();
@Rule
public TemporaryFolder outputFolder = new TemporaryFolder();
@After
public void tearDown() throws IOException {
RepairnatorConfig.deleteInstance();
}
@Test
public void TestPipelineSoboFeedbackTool() throws Exception {
Launcher launcher = new Launcher(new String[]{
"--gitrepourl", "https://gits-15.sys.kth.se/inda-19/linusost-task-11",
"--gitcommithash", "10b75090bf93ecae250ace247cf1815c7c5b084b",
"--sonarRules", "S109",
"--feedbackTools", "SoboBot",
"--launcherMode", "FEEDBACK",
"--workspace", workspaceFolder.getRoot().getAbsolutePath(),
"--output", outputFolder.getRoot().getAbsolutePath()
});
assertEquals(0, launcher.getConfig().getRepairTools().size());
assertEquals(1, launcher.getConfig().getFeedbackTools().size());
assertTrue(launcher.getConfig().getLauncherMode().equals(LauncherMode.FEEDBACK));
assertFalse(launcher.getConfig().getCommandFunctionality());
assertTrue(launcher.getConfig().getFeedbackTools().contains("SoboBot"));
assertFalse(launcher.getConfig().getRepairTools().contains("SoboBot"));
Patches patchNotifier = new Patches();
launcher.setPatchNotifier(patchNotifier);
launcher.mainProcess();
//List<AbstractStep> steps = launcher.getInspector().getSteps()
// .stream()
// .filter(step -> step.getName().equals("SoboBot"))
// .collect(Collectors.toList()); //test fix sorald-bot repair
//assertEquals(1, steps.size());
}
class Patches implements PatchNotifier {
List<RepairPatch> allpatches = new ArrayList<>();
@Override
public void notify(ProjectInspector inspector, String toolname, List<RepairPatch> patches) {
allpatches.addAll(patches);
}
}
@VisibleForTesting
String getEnv(String name) {
return System.getenv(name);
}
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.feedback.sobo;
import com.google.common.collect.Lists;
import fr.inria.spirals.repairnator.process.inspectors.ProjectInspector;
import fr.inria.spirals.repairnator.process.step.StepStatus;
import fr.inria.spirals.repairnator.process.step.feedback.AbstractFeedbackStep;
import fr.inria.spirals.repairnator.process.step.repair.soraldbot.SoraldAdapter;
import fr.inria.spirals.repairnator.process.step.repair.soraldbot.models.SoraldTargetCommit;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.kohsuke.github.GHCommit;
import org.kohsuke.github.GHUser;
import org.kohsuke.github.GitHub;
import java.io.File;
import java.io.IOException;
import java.util.*;
public class SoboBot extends AbstractFeedbackStep {
private SoraldTargetCommit commit;
private String originalBranchName;
private String workingRepoPath;
private static final String REPO_PATH = "tmp_repo";
public SoboBot(ProjectInspector inspector) {
super(inspector, true);
}
public SoboBot() {
super();
}
/**
* {@return if the initialization is successful}
*/
private boolean init() {
commit = new SoraldTargetCommit(getConfig().getGitCommitHash(), getInspector().getRepoSlug());
workingRepoPath = getInspector().getWorkspace() + File.separator + REPO_PATH;
try {
originalBranchName = getOriginalBranch();
} catch (IOException | GitAPIException e) {
getLogger().error("IOException while looking for the original branch: " + e.getLocalizedMessage());
}
return commit != null && workingRepoPath != null && originalBranchName != null;
}
@Override
protected StepStatus businessExecute() {
Git git = null;
try {
git = getInspector().openAndGetGitObject();
} catch (IOException e) {
getInspector().getLogger().info("Not able to open GitHub Object");
}
Repository repo = git.getRepository();
String repoOwnerUserName = getUserName(getInspector().getRepoSlug());
String task = getTask(getInspector().getRepoSlug());
if (System.getenv("command").equals("true") ) {
try {
SoboAdapter.getInstance(getInspector().getWorkspace()).readCommand(getInspector(), repoOwnerUserName, task, getInspector().getRepoSlug());
return StepStatus.buildSuccess(this);
} catch (Exception e) {
getInspector().getLogger().info("can't read command");
return StepStatus.buildSkipped(this, "There are no new commands to process");
}
} else {
boolean successfulInit = init();
if (!successfulInit) {
return StepStatus.buildSkipped(this, "Error while sending feedback with Sobo");
}
getLogger().info("Working on: " + commit.getCommitId() + " -- On repo: " + commit.getRepoName());
GitHub github = SoboAdapter.getInstance(getInspector().getWorkspace()).connectWithGH();
String commitAuthor;
GHCommit commitObject;
Date commitDate;
try {
commitObject = github.getRepository(getInspector().getRepoSlug()).getCommit(commit.getCommitId());
if(commitObject.getAuthor()!=null){
commitAuthor = commitObject.getAuthor().getLogin();}
else commitAuthor= repoOwnerUserName;
commitDate=commitObject.getCommitDate();
getLogger().info("Commit author : "+ commitAuthor);
} catch (IOException e) {
e.printStackTrace();
return StepStatus.buildSkipped(this, "Error while getting commit author");
}
String rules = System.getenv("SONAR_RULES")!=null? System.getenv("SONAR_RULES"): SoboConstants.RULES_SLOT_1;//Arrays.asList(RepairnatorConfig.getInstance().getSonarRules());
getLogger().info("Working with rules: " + rules);
String dir = getInspector().getWorkspace() + "\\stats.json";
boolean isRepoAuthorized4AutomaticFeedback=SoboAdapter.getInstance(getInspector().getWorkspace()).checkUserRepo(repoOwnerUserName, task) ;
boolean isCommitAuthorStudent=SoboAdapter.getInstance(getInspector().getWorkspace()).checkUser(commitAuthor);
if (isRepoAuthorized4AutomaticFeedback && isCommitAuthorStudent) {
try {
getLogger().info("Mining Sonar Rules");
SoraldAdapter.getInstance(getInspector().getWorkspace()).mine(rules, repo.getDirectory().getParentFile(), dir);
} catch (Exception e) {
return StepStatus.buildSkipped(this, "Error while mining with Sorald");
}
try{
getLogger().info("Catching mining File and sending the data to MongoDB");
SoboAdapter.getInstance(getInspector().getWorkspace()).readExitFile(dir, commit.getCommitId(), commitAuthor, task, getInspector(), commitDate);
} catch (Exception e) {
return StepStatus.buildSkipped(this, "Error while analizing exit file");
}
try{
getLogger().info("Getting the most common rule, creating the issue and updating db");
//create the issue //String commit, String user, String task, ProjectInspector inspector
SoboAdapter.getInstance(getInspector().getWorkspace()).getMostCommonRule(commit.getCommitId(), commitAuthor, task, getInspector());
} catch (Exception e) {
return StepStatus.buildSkipped(this, "Error while analyzing exit file");
}
}
return StepStatus.buildSuccess(this);
}
}
@Override
public String getFeedbackToolName() {
return SoboConstants.SOBO_TOOL_NAME;
}
private String getOriginalBranch() throws IOException, GitAPIException {
String branchName = getBranchOfCommit(getInspector().getRepoLocalPath(), commit.getCommitId());
if (branchName == null) {
getLogger().error("The branch of the commit was not found");
return null;
}
return branchName;
}
public String getBranchOfCommit(String gitDir, String commitName) throws IOException, GitAPIException {
Git git = getInspector().openAndGetGitObject();
List<Ref> branches = git.branchList().call();
Set<String> containingBranches = new HashSet<>();
for (Ref branch : branches) {
String branchName = branch.getName();
Iterable<RevCommit> commits = git.log().add(git.getRepository().resolve(branchName)).call();
List<RevCommit> commitsList = Lists.newArrayList(commits.iterator());
if (commitsList.stream().anyMatch(rev -> rev.getName().equals(commitName))) {
containingBranches.add(branchName);
}
}
git.close();
if (containingBranches.size() == 0)
return null;
Optional<String> selectedBranch = containingBranches.stream()
.filter(b -> b.equals("master") || b.equals("main") || b.contains("/master") || b.contains("/main")).findAny();
return selectedBranch.isPresent() ? selectedBranch.get() : containingBranches.iterator().next();
}
/**
*
* @param repoName the slug of the student repository following the sintax inda-{year}/{user}-task-{n}
* @return userName of the owner of the repo
*/
public String getUserName(String repoName){
char[] chars = repoName.toCharArray();
String user="";
int index = repoName.indexOf("inda-");
if (index!=-1){
for(int i =index+8;i< chars.length;i++){
if(chars[i]=='-'){
return user;
}
user+=chars[i];
}
return user;
}
index = repoName.indexOf('/');
for(int i =0;i<index;i++){
user+=chars[i];
}
return user;
}
/**
*
* @param repoName the slug of the student repository following the sintax inda-{year}/{user}-task-{n}
* @return task related to the repository
*/
public String getTask(String repoName){
StringBuilder task= new StringBuilder();
char[] chars = repoName.toCharArray();
// iterate over `char[]` array using enhanced for-loop
int index = repoName.indexOf("task-");
if (index==-1){
return task.toString();
}
for(int i =index;i< chars.length;i++){
task.append(chars[i]);
}
return task.toString();
}
}
```
|
```package fr.inria.spirals.repairnator.process.utils4tests;
public class Constants4Tests {
public static final String Z3_SOLVER_PATH_DIR = "src/test/resources/z3/";
public static final String Z3_SOLVER_NAME_LINUX = "z3_for_linux";
public static final String Z3_SOLVER_NAME_MAC = "z3_for_mac";
}
```
|
Please help me generate a test for this class.
|
```package fr.inria.spirals.repairnator.process.step.repair.soraldbot;
public class SoraldConstants {
public static final String SORALD_GIT_PATCHES_DIR = "SoraldGitPatches";
public static final String SPOON_SNIPER_MODE = "SNIPER";
public static final String SORALD_TOOL_NAME = "SoraldBot";
}
```
|
```package com.doinb.reflect;
/**
* @author ddd
* @description TODO
* @createTime 2022/07/28
*/
public class TestUser {
}
```
|
Please help me generate a test for this class.
|
```package com.doinb.spring.ioc;
import lombok.Data;
@Data
public class User {
private String name;
private int age;
}
```
|
```package org.hive2hive.core.model;
import java.security.KeyPair;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.file.FileUtil;
import org.hive2hive.core.security.EncryptionUtil;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* Tests the file tree node
*
* @author Nico, Seppi
*/
public class IndexTest extends H2HJUnitTest {
private final String userId = "UserA";
private FolderIndex root;
private Index child1;
private Index child2;
private FolderIndex dir1;
private Index child3;
private FolderIndex dir2;
private FolderIndex dir3;
private FolderIndex dir4;
@BeforeClass
public static void initTest() throws Exception {
testClass = IndexTest.class;
beforeClass();
}
@AfterClass
public static void cleanAfterClass() {
afterClass();
}
@Before
public void createTreeNode() {
// create a tree
KeyPair keys = generateRSAKeyPair(H2HConstants.KEYLENGTH_META_FILE);
KeyPair protectionKeys = generateRSAKeyPair(H2HConstants.KEYLENGTH_META_FILE);
root = new FolderIndex(null, keys, null);
root.addUserPermissions(new UserPermission(userId, PermissionType.WRITE));
root.setProtectionKeys(protectionKeys);
// naming convention:
// [number][type][index] where number is the level and type is either 'f' for file or 'd' for
// directory. The index is to distinct two files/folders on the same level
// setup is like
// root:
// - child1
// - child2
// - 1d:
// - - child3
// - - 2d (empty folder)
// - - 3d:
// - - - 4d (empty folder)
child1 = new FileIndex(root, keys, "1f1", null);
child2 = new FileIndex(root, keys, "1f2", null);
dir1 = new FolderIndex(root, keys, "1d");
child3 = new FileIndex(dir1, keys, "2f", null);
dir2 = new FolderIndex(dir1, keys, "2d");
dir3 = new FolderIndex(dir1, keys, "3d");
dir4 = new FolderIndex(dir3, keys, "4d");
}
@Test
public void testFullPath() {
Assert.assertEquals("", root.getFullPath().toString());
Assert.assertEquals("1f1", child1.getFullPath().toString());
Assert.assertEquals("1f2", child2.getFullPath().toString());
Assert.assertEquals("1d" + FileUtil.getFileSep(), dir1.getFullPath().toString());
Assert.assertEquals("1d" + FileUtil.getFileSep() + "2f", child3.getFullPath().toString());
Assert.assertEquals("1d" + FileUtil.getFileSep() + "2d" + FileUtil.getFileSep(), dir2.getFullPath().toString());
Assert.assertEquals("1d" + FileUtil.getFileSep() + "3d" + FileUtil.getFileSep(), dir3.getFullPath().toString());
Assert.assertEquals("1d" + FileUtil.getFileSep() + "3d" + FileUtil.getFileSep() + "4d" + FileUtil.getFileSep(), dir4
.getFullPath().toString());
}
@Test
public void testShare() {
// set 1d to be shared (use a shorter key to speed up)
dir1.share(generateRSAKeyPair(EncryptionUtil.RSA_KEYLENGTH.BIT_512));
// 1d, 2f, 2d, 3d and 4d should return to be shared, others not
Assert.assertTrue(dir1.isShared());
Assert.assertTrue(dir2.isShared());
Assert.assertTrue(child3.isShared());
Assert.assertTrue(dir3.isShared());
Assert.assertTrue(dir4.isShared());
Assert.assertFalse(root.isShared());
Assert.assertFalse(child1.isShared());
Assert.assertFalse(child2.isShared());
// set 1d to be not shared
dir1.unshare();
// root, 1f1, 1f2, 1d, 2f and 2d should return to be not shared
Assert.assertFalse(root.isShared());
Assert.assertFalse(dir1.isShared());
Assert.assertFalse(dir2.isShared());
Assert.assertFalse(dir3.isShared());
Assert.assertFalse(dir4.isShared());
Assert.assertFalse(child1.isShared());
Assert.assertFalse(child2.isShared());
Assert.assertFalse(child3.isShared());
}
@Test(expected = IllegalStateException.class)
public void testShareRoot() {
// (use a shorter key to speed up)
root.share(generateRSAKeyPair(EncryptionUtil.RSA_KEYLENGTH.BIT_512));
}
@Test
public void testHasShared() {
// set 2d to be shared (use a shorter key to speed up)
dir2.share(generateRSAKeyPair(EncryptionUtil.RSA_KEYLENGTH.BIT_512));
// root, 1d and 2d should show that they contain a shared folder
Assert.assertTrue(root.isSharedOrHasSharedChildren());
Assert.assertTrue(dir1.isSharedOrHasSharedChildren());
Assert.assertTrue(dir2.isSharedOrHasSharedChildren());
Assert.assertFalse(child1.isSharedOrHasSharedChildren());
Assert.assertFalse(child2.isSharedOrHasSharedChildren());
Assert.assertFalse(child3.isSharedOrHasSharedChildren());
// set 2d to be not shared
dir2.unshare();
// root, 1f1, 1f2, 1d, 2f and 2d should not contain a shared folder
Assert.assertFalse(root.isSharedOrHasSharedChildren());
Assert.assertFalse(dir1.isSharedOrHasSharedChildren());
Assert.assertFalse(dir2.isSharedOrHasSharedChildren());
Assert.assertFalse(child1.isSharedOrHasSharedChildren());
Assert.assertFalse(child2.isSharedOrHasSharedChildren());
Assert.assertFalse(child3.isSharedOrHasSharedChildren());
}
@Test
public void testGetChildByName() {
Assert.assertEquals(child1, root.getChildByName("1f1"));
Assert.assertEquals(dir1, root.getChildByName("1d"));
Assert.assertEquals(dir3, dir1.getChildByName("3d"));
Assert.assertEquals(dir4, dir3.getChildByName("4d"));
Assert.assertEquals(null, root.getChildByName("2f"));
Assert.assertEquals(null, root.getChildByName(null));
Assert.assertEquals(null, root.getChildByName(""));
}
@Test
public void testPermissions() {
Assert.assertTrue(root.getCalculatedUserList().contains(userId));
Assert.assertEquals(1, root.getCalculatedUserList().size());
// add permission to sub-folder
dir1.share(generateRSAKeyPair(H2HConstants.KEYLENGTH_META_FILE));
dir1.addUserPermissions(new UserPermission(userId, PermissionType.WRITE));
dir1.addUserPermissions(new UserPermission("UserB", PermissionType.READ));
// check the sub-folder and the sub-files permission
Assert.assertEquals(2, dir1.getCalculatedUserList().size());
Assert.assertEquals(2, child3.getCalculatedUserList().size());
Assert.assertEquals(2, dir2.getCalculatedUserList().size());
Assert.assertEquals(2, dir3.getCalculatedUserList().size());
Assert.assertEquals(2, dir4.getCalculatedUserList().size());
Assert.assertTrue(dir1.canWrite("UserA"));
Assert.assertFalse(dir1.canWrite("UserB"));
Assert.assertTrue(dir2.canWrite("UserA"));
Assert.assertFalse(dir2.canWrite("UserB"));
Assert.assertTrue(dir3.canWrite("UserA"));
Assert.assertFalse(dir3.canWrite("UserB"));
Assert.assertTrue(dir4.canWrite("UserA"));
Assert.assertFalse(dir4.canWrite("UserB"));
// validate that the root still has only one user
Assert.assertTrue(root.getCalculatedUserList().contains(userId));
Assert.assertEquals(1, root.getCalculatedUserList().size());
// add a third permission to the dir1
dir1.addUserPermissions(new UserPermission("UserC", PermissionType.WRITE));
// check again
Assert.assertEquals(3, dir1.getCalculatedUserList().size());
Assert.assertEquals(3, child3.getCalculatedUserList().size());
Assert.assertEquals(3, dir2.getCalculatedUserList().size());
Assert.assertEquals(3, dir3.getCalculatedUserList().size());
Assert.assertEquals(3, dir4.getCalculatedUserList().size());
Assert.assertTrue(dir1.canWrite("UserC"));
Assert.assertTrue(dir2.canWrite("UserC"));
Assert.assertTrue(dir3.canWrite("UserC"));
Assert.assertTrue(dir4.canWrite("UserC"));
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.model;
import java.io.File;
import java.io.Serializable;
import java.security.KeyPair;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import org.hive2hive.core.file.FileUtil;
import org.hive2hive.core.model.versioned.MetaFileLarge;
import org.hive2hive.core.model.versioned.MetaFileSmall;
public abstract class Index implements Comparable<Index>, Serializable {
private static final long serialVersionUID = -2643129713985680901L;
protected final KeyPair fileKeys;
protected String name;
protected FolderIndex parent;
/**
* Constructor for root node.
*
* @param fileKeys the root file keys
*/
public Index(KeyPair fileKeys) {
this(fileKeys, null, null);
}
public Index(KeyPair fileKeys, String name, FolderIndex parent) {
if (fileKeys == null) {
throw new IllegalArgumentException("File keys can't be null.");
}
this.fileKeys = fileKeys;
this.name = name;
this.parent = parent;
if (parent != null) {
parent.addChild(this);
}
}
/**
* The {@link MetaFileSmall} or {@link MetaFileLarge} is encrypted with this keypair.
*
* @return the keypair
*/
public KeyPair getFileKeys() {
return fileKeys;
}
/**
* Convenience method that returns the public key of the file keys
*
* @return the public key
*/
public PublicKey getFilePublicKey() {
return fileKeys.getPublic();
}
/**
* Returns the name of the file
*
* @return the name of the file that this index references
*/
public String getName() {
return name;
}
/**
* Changes the name of the index. The name is the same as the name of the file.
*
* @param name the name of the index
*/
public void setName(String name) {
this.name = name;
}
/**
* Set the parent index (used when the parent may be changed)
*
* @param parent the parent index
*/
public void setParent(FolderIndex parent) {
if (parent == null) {
throw new IllegalArgumentException("Parent can't be null.");
}
this.parent = parent;
}
public void decoupleFromParent() {
this.parent = null;
}
/**
* Returns the parent of the index.
*
* @return the parent of the current index. This call returns null if the index is root
*/
public FolderIndex getParent() {
return parent;
}
/**
* Returns the folder that is shared (can be this node or a parent / grand-parent / ... of this node)
*
* @return the top folder of the share
*/
public FolderIndex getSharedTopFolder() {
if (this instanceof FileIndex) {
// is not shared and is of type files (this has no children)
return parent.getSharedTopFolder();
} else {
// is of type folder
FolderIndex folder = (FolderIndex) this;
if (folder.getSharedFlag()) {
// this is the top-most shared folder because the shared flag is activated
return folder;
} else if (folder.isRoot()) {
// the root folder is never shared
return null;
} else {
// move one level up (recursion)
return parent.getSharedTopFolder();
}
}
}
/**
* Return sif the node is shared or has any children that are shared.
*
* @return if the node is shared or has a shared sub-section
*/
public boolean isSharedOrHasSharedChildren() {
if (isShared()) {
// this is a shared file or a shared (sub) folder
return true;
}
if (this instanceof FileIndex) {
// is not shared and is of type 'file'
return false;
} else {
// is of type 'folder', check all subfolders
List<Index> children = getIndexList(this);
for (Index child : children) {
if (child.isFolder()) {
FolderIndex subfolder = (FolderIndex) child;
if (subfolder.getSharedFlag()) {
return true;
}
}
}
}
// no case above matches
return false;
}
/**
* Returns the full path string (starting at the root) of this node
*
* @return the full path, whereas names are separated with the operating systems file separator
*/
public String getFullPath() {
if (parent == null) {
return "";
} else {
if (isFile()) {
return parent.getFullPath() + name;
} else {
return parent.getFullPath() + name + FileUtil.getFileSep();
}
}
}
/**
* Converts the index to a file
*
* @param root the root folder
* @return the file
*/
public File asFile(File root) {
if (parent == null) {
return root;
} else {
return new File(parent.asFile(root), getName());
}
}
/**
* Returns whether this index belongs to a shared area
*
* @return if the index is shared
*/
public abstract boolean isShared();
/**
* Returns a list of users that can at least read the file
*
* @return the set of users that have access to this folder (read or write)
*/
public abstract Set<String> getCalculatedUserList();
/**
* Returns the responsible protection keys (depends of the shared state). The {@link MetaFileSmall} or
* {@link MetaFileLarge} and all {@link Chunk}s are protected with this key.
*
* @return the protection keys (or the default protection keys, set to the root). The result should never
* be null.
*/
public abstract KeyPair getProtectionKeys();
/**
* Convenience method to ask whether the index is a folder
*
* @return <code>true</code> if this is an instance of a {@link FolderIndex}. Otherwise, it must be an
* instance of {@link FileIndex}.
*/
public abstract boolean isFolder();
/**
* Returns whether the user can write and upload a file / sub-folder to this directory
*
* @return <code>true</code> if this user is allowed to write to this folder
*/
public abstract boolean canWrite();
/**
* Convenience method to ask whether the index is a file
*
* @return <code>true</code> if this is an instance of a {@link FileIndex}. Otherwise, it must be an
* instance of {@link FolderIndex}.
*/
public boolean isFile() {
return !isFolder();
}
@Override
public int compareTo(Index other) {
return this.getFullPath().compareTo(other.getFullPath());
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
} else if (obj instanceof String) {
String otherPath = (String) obj;
return getFullPath().equals(otherPath);
} else if (obj instanceof KeyPair) {
KeyPair otherKey = (KeyPair) obj;
return fileKeys.equals(otherKey);
} else if (obj instanceof Index) {
Index otherIndex = (Index) obj;
return fileKeys.equals(otherIndex.getFileKeys());
}
return false;
}
@Override
public int hashCode() {
if (fileKeys != null) {
return fileKeys.hashCode();
}
return super.hashCode();
}
@Override
public abstract String toString();
/**
* Walks recursively through the file tree and returns a preorder list
*
* @param node The root node from which the digest is started.
* @return The digest in preorder
*/
public static List<Index> getIndexList(Index node) {
List<Index> digest = new ArrayList<Index>();
// add self
digest.add(node);
// add children
if (node.isFolder()) {
FolderIndex folder = (FolderIndex) node;
for (Index child : folder.getChildren()) {
digest.addAll(getIndexList(child));
}
}
return digest;
}
}
```
|
```package org.hive2hive.core.events;
import static org.junit.Assert.fail;
import java.io.IOException;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.exceptions.NoSessionException;
import org.junit.Ignore;
import org.junit.Test;
@Ignore
public class FileShareEventsTest extends FileEventsTest {
@Test
public void testFileShareEvent() throws NoPeerConnectionException, IOException, NoSessionException {
// TODO
fail("not implemented yet");
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.events.framework.interfaces.file;
import java.util.Set;
import org.hive2hive.core.model.UserPermission;
public interface IFileShareEvent extends IFileEvent {
/**
* @return the permissions of all users for the shared folder
*/
Set<UserPermission> getUserPermissions();
/**
* @param userId the userId to ask the permission. <code>null</code> will be returned in case the userId
* does not have any permission.
* @return the permission for this shared folder for the given user
*/
UserPermission getUserPermission(String userId);
/**
* @return the host that invited to share
*/
String getInvitedBy();
}
```
|
```package org.hive2hive.core.events;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import java.math.BigInteger;
import java.util.List;
import org.hive2hive.core.events.framework.interfaces.file.IFileAddEvent;
import org.hive2hive.core.events.framework.interfaces.file.IFileEvent;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.exceptions.NoSessionException;
import org.hive2hive.core.utils.FileTestUtil;
import org.hive2hive.core.utils.TestFileConfiguration;
import org.hive2hive.core.utils.UseCaseTestUtil;
import org.junit.Test;
public class FileAddEventsTest extends FileEventsTest {
static {
testClass = FileAddEventsTest.class;
}
@Test
public void testFileAddEvent() throws NoPeerConnectionException, IOException, NoSessionException {
// upload a file from machine A
File file = createAndAddFile(rootA, clientA);
// wait for the event
waitForNumberOfEvents(1);
// check event type
List<IFileEvent> events = listener.getEvents();
assertEventType(events, IFileAddEvent.class);
// check path
assertTrue(events.size() == 1);
IFileEvent ev = events.get(0);
assertTrue(ev.isFile());
assertEqualsRelativePaths(file, ev.getFile());
}
@Test
public void testBigFileAddEvent() throws NoPeerConnectionException, IOException, NoSessionException {
// upload a big file from machine A
BigInteger maxFileSize = new TestFileConfiguration().getMaxFileSize();
int minChunks = (int) maxFileSize.longValue() / TestFileConfiguration.CHUNK_SIZE;
String fileName = randomString();
File file = FileTestUtil.createFileRandomContent(fileName, minChunks + 1, rootA);
UseCaseTestUtil.uploadNewFile(clientA, file);
// wait for the event
waitForNumberOfEvents(1);
// get event and check type
List<IFileEvent> events = listener.getEvents();
assertEventType(events, IFileAddEvent.class);
// check path
assertTrue(events.size() == 1);
IFileEvent ev = events.get(0);
assertTrue(ev.isFile());
assertEqualsRelativePaths(file, ev.getFile());
}
@Test
public void testEmptyFolderAddEvent() throws NoPeerConnectionException, IOException, NoSessionException {
// create and upload a folder from machine A
File folder = createAndAddFolder(rootA, clientA);
// wait for event on B
waitForNumberOfEvents(1);
// check type of event
List<IFileEvent> events = listener.getEvents();
assertEventType(events, IFileAddEvent.class);
// check paths
assertTrue(events.size() == 1);
IFileEvent ev = events.get(0);
assertFalse(ev.isFile());
assertEqualsRelativePaths(folder, ev.getFile());
}
@Test
public void testFolderWithFilesAddEvent() throws NoPeerConnectionException, IOException, NoSessionException {
List<File> files = createAndAddFolderWithFiles(rootA, clientA);
// wait for events on other side (clientB)
waitForNumberOfEvents(files.size());
// check number of received events and their type
List<IFileEvent> events = listener.getEvents();
assertEventType(events, IFileAddEvent.class);
assertTrue(events.size() == files.size());
// match file paths of events with uploaded files
for (int i = 0; i < events.size(); ++i) {
IFileEvent ev = events.get(i);
File f = files.get(i);
assertTrue(f.isFile() == ev.isFile());
assertEqualsRelativePaths(f, ev.getFile());
}
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.events.framework.interfaces.file;
public interface IFileAddEvent extends IFileEvent {
}
```
|
```package org.hive2hive.core.processes.share.pkupdate;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.SignatureException;
import java.util.ArrayList;
import java.util.List;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import net.tomp2p.peers.Number160;
import org.bouncycastle.crypto.DataLengthException;
import org.bouncycastle.crypto.InvalidCipherTextException;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.model.Chunk;
import org.hive2hive.core.model.FileVersion;
import org.hive2hive.core.model.MetaChunk;
import org.hive2hive.core.model.versioned.HybridEncryptedContent;
import org.hive2hive.core.model.versioned.MetaFileSmall;
import org.hive2hive.core.network.NetworkManager;
import org.hive2hive.core.network.data.parameters.Parameters;
import org.hive2hive.core.processes.context.BasePKUpdateContext;
import org.hive2hive.core.security.H2HDefaultEncryption;
import org.hive2hive.core.security.H2HDummyEncryption;
import org.hive2hive.core.utils.NetworkTestUtil;
import org.hive2hive.core.utils.TestExecutionUtil;
import org.hive2hive.processframework.exceptions.InvalidProcessStateException;
import org.hive2hive.processframework.exceptions.ProcessRollbackException;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* Tests the step that changes the content protection key in the DHT.
*
* @author Seppi
*/
public class ChangeProtectionKeysStepTest extends H2HJUnitTest {
private static List<NetworkManager> network;
private static H2HDummyEncryption dummyEncryption;
@BeforeClass
public static void initTest() throws Exception {
testClass = ChangeProtectionKeysStepTest.class;
beforeClass();
network = NetworkTestUtil.createNetwork(DEFAULT_NETWORK_SIZE);
dummyEncryption = new H2HDummyEncryption();
}
@Test
public void testStepSuccessAndRollbackWithChunk() throws InterruptedException, NoPeerConnectionException,
DataLengthException, InvalidKeyException, IllegalStateException, InvalidCipherTextException,
IllegalBlockSizeException, BadPaddingException, IOException, SignatureException, InvalidProcessStateException,
ProcessRollbackException {
// where the process runs
NetworkManager getter = network.get(0);
// where the data gets stored
NetworkManager proxy = network.get(1);
// generate necessary keys
KeyPair encryptionKeys = generateRSAKeyPair(H2HConstants.KEYLENGTH_CHUNK);
KeyPair protectionKeysOld = generateRSAKeyPair(H2HConstants.KEYLENGTH_PROTECTION);
KeyPair protectionKeysNew = generateRSAKeyPair(H2HConstants.KEYLENGTH_PROTECTION);
// generate a fake chunk
Chunk chunk = new Chunk(proxy.getNodeId(), randomString().getBytes(), 0);
// encrypt the chunk
HybridEncryptedContent encryptedChunk = dummyEncryption.encryptHybrid(chunk, encryptionKeys.getPublic());
// initialize put
Parameters parameters = new Parameters().setLocationKey(chunk.getId()).setContentKey(H2HConstants.FILE_CHUNK)
.setProtectionKeys(protectionKeysOld).setNetworkContent(encryptedChunk);
// indicate to generate hash
parameters.setHashFlag(true);
// put encrypted chunk into network
getter.getDataManager().putUnblocked(parameters).awaitUninterruptibly();
// verify put
Assert.assertNotNull(getter.getDataManager().getUnblocked(parameters).awaitUninterruptibly().data());
// initialize a fake process context
BasePKUpdateContext context = new TestChunkPKUpdateContext(protectionKeysOld, protectionKeysNew, chunk,
parameters.getHash());
// create a change protection keys process step
ChangeProtectionKeysStep step = new ChangeProtectionKeysStep(context, getter.getDataManager());
// run process, should not fail
TestExecutionUtil.executeProcessTillSucceded(step);
// verify if content protection keys have changed
Assert.assertEquals(protectionKeysNew.getPublic(), getter.getDataManager().getUnblocked(parameters)
.awaitUninterruptibly().data().publicKey());
// manually trigger roll back
step.rollback();
// verify if content protection keys have changed to old ones
Assert.assertEquals(protectionKeysOld.getPublic(), getter.getDataManager().getUnblocked(parameters)
.awaitUninterruptibly().data().publicKey());
}
@Test
public void testStepSuccessAndRollbackWithMetaFile() throws InterruptedException, NoPeerConnectionException,
DataLengthException, InvalidKeyException, IllegalStateException, InvalidCipherTextException,
IllegalBlockSizeException, BadPaddingException, IOException, SignatureException, InvalidProcessStateException,
ProcessRollbackException {
// where the process runs
NetworkManager getter = network.get(0);
// generate necessary keys
KeyPair chunkEncryptionKeys = generateRSAKeyPair(H2HConstants.KEYLENGTH_CHUNK);
KeyPair metaFileEncryptionKeys = generateRSAKeyPair(H2HConstants.KEYLENGTH_META_FILE);
KeyPair protectionKeysOld = generateRSAKeyPair(H2HConstants.KEYLENGTH_PROTECTION);
KeyPair protectionKeysNew = generateRSAKeyPair(H2HConstants.KEYLENGTH_PROTECTION);
// generate a fake meta file
List<MetaChunk> metaChunks1 = new ArrayList<MetaChunk>();
metaChunks1.add(new MetaChunk(randomString(), randomString().getBytes(), 0));
metaChunks1.add(new MetaChunk(randomString(), randomString().getBytes(), 1));
List<MetaChunk> metaChunks2 = new ArrayList<MetaChunk>();
metaChunks2.add(new MetaChunk(randomString(), randomString().getBytes(), 2));
List<FileVersion> fileVersions = new ArrayList<FileVersion>();
fileVersions.add(new FileVersion(0, 123, System.currentTimeMillis(), metaChunks1));
fileVersions.add(new FileVersion(1, 123, System.currentTimeMillis(), metaChunks2));
MetaFileSmall metaFileSmall = new MetaFileSmall(metaFileEncryptionKeys.getPublic(), fileVersions,
chunkEncryptionKeys);
// encrypt the meta file
HybridEncryptedContent encryptedMetaFile = dummyEncryption.encryptHybrid(metaFileSmall,
metaFileEncryptionKeys.getPublic());
encryptedMetaFile.generateVersionKey();
// initialize put
Parameters parameters = new Parameters().setLocationKey(metaFileSmall.getId()).setContentKey(H2HConstants.META_FILE)
.setVersionKey(encryptedMetaFile.getVersionKey()).setProtectionKeys(protectionKeysOld)
.setNetworkContent(encryptedMetaFile);
// indicate to generate hash
parameters.setHashFlag(true);
// put encrypted meta file into network
getter.getDataManager().putUnblocked(parameters).awaitUninterruptibly();
// verify put
Assert.assertNotNull(getter.getDataManager().getUnblocked(parameters).awaitUninterruptibly().data());
// initialize a fake process context
BasePKUpdateContext context = new TestMetaFilePKUpdateContext(protectionKeysOld, protectionKeysNew, metaFileSmall,
parameters.getHash(), encryptedMetaFile.getVersionKey());
// create a change protection keys process step
ChangeProtectionKeysStep step = new ChangeProtectionKeysStep(context, getter.getDataManager());
// run process, should not fail
TestExecutionUtil.executeProcessTillSucceded(step);
// verify if content protection keys have changed
Assert.assertEquals(protectionKeysNew.getPublic(), getter.getDataManager().getUnblocked(parameters)
.awaitUninterruptibly().data().publicKey());
// manually trigger roll back
step.rollback();
// verify if content protection keys have changed to old ones
Assert.assertEquals(protectionKeysOld.getPublic(), getter.getDataManager().getUnblocked(parameters)
.awaitUninterruptibly().data().publicKey());
}
@AfterClass
public static void endTest() {
NetworkTestUtil.shutdownNetwork(network);
afterClass();
}
private class TestChunkPKUpdateContext extends BasePKUpdateContext {
private final Chunk chunk;
private final byte[] hash;
public TestChunkPKUpdateContext(KeyPair oldProtectionKeys, KeyPair newProtectionKeys, Chunk chunk, byte[] hash) {
super(oldProtectionKeys, newProtectionKeys);
this.chunk = chunk;
this.hash = hash;
}
@Override
public String getLocationKey() {
return chunk.getId();
}
@Override
public String getContentKey() {
return H2HConstants.FILE_CHUNK;
}
@Override
public int getTTL() {
return chunk.getTimeToLive();
}
@Override
public byte[] getHash() {
return hash;
}
@Override
public Number160 getVersionKey() {
return H2HConstants.TOMP2P_DEFAULT_KEY;
}
}
private class TestMetaFilePKUpdateContext extends BasePKUpdateContext {
private final MetaFileSmall metaFileSmall;
private final byte[] hash;
private final Number160 versionKey;
public TestMetaFilePKUpdateContext(KeyPair oldProtectionKeys, KeyPair newProtectionKeys,
MetaFileSmall metaFileSmall, byte[] hash, Number160 versionKey) {
super(oldProtectionKeys, newProtectionKeys);
this.metaFileSmall = metaFileSmall;
this.hash = hash;
this.versionKey = versionKey;
}
@Override
public String getLocationKey() {
return H2HDefaultEncryption.key2String(metaFileSmall.getId());
}
@Override
public String getContentKey() {
return H2HConstants.META_FILE;
}
@Override
public int getTTL() {
return metaFileSmall.getTimeToLive();
}
@Override
public byte[] getHash() {
return hash;
}
@Override
public Number160 getVersionKey() {
return versionKey;
}
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.processes.share.pkupdate;
import org.hive2hive.core.model.BaseNetworkContent;
import org.hive2hive.core.network.data.DataManager;
import org.hive2hive.core.network.data.parameters.IParameters;
import org.hive2hive.core.network.data.parameters.Parameters;
import org.hive2hive.core.processes.context.BasePKUpdateContext;
import org.hive2hive.processframework.ProcessStep;
import org.hive2hive.processframework.exceptions.InvalidProcessStateException;
import org.hive2hive.processframework.exceptions.ProcessExecutionException;
import org.hive2hive.processframework.exceptions.ProcessRollbackException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Changes the protection key for any data of type {@link BaseNetworkContent}. Use the
* {@link BasePKUpdateContext} to hand over the required data.
*
* @author Nico, Seppi
*/
public class ChangeProtectionKeysStep extends ProcessStep<Void> {
private static final Logger logger = LoggerFactory.getLogger(ChangeProtectionKeysStep.class);
private final BasePKUpdateContext context;
private final DataManager dataManager;
private IParameters parameters;
public ChangeProtectionKeysStep(BasePKUpdateContext context, DataManager dataManager) {
this.setName(getClass().getName());
this.context = context;
this.dataManager = dataManager;
}
@Override
protected Void doExecute() throws InvalidProcessStateException, ProcessExecutionException {
parameters = new Parameters().setLocationKey(context.getLocationKey()).setContentKey(context.getContentKey())
.setVersionKey(context.getVersionKey()).setProtectionKeys(context.consumeOldProtectionKeys())
.setNewProtectionKeys(context.consumeNewProtectionKeys()).setTTL(context.getTTL())
.setHash(context.getHash());
boolean success = dataManager.changeProtectionKey(parameters);
setRequiresRollback(success);
if (!success) {
throw new ProcessExecutionException(this, String.format(
"Could not change content protection keys. Parameters: %s.", parameters.toString()));
}
logger.debug("Successfully changed the protection keys for {}", parameters);
return null;
}
@Override
protected Void doRollback() throws InvalidProcessStateException, ProcessRollbackException {
logger.debug("Rollbacking change of content protection key. '{}'", parameters.toString());
Parameters rollbackParameters = new Parameters().setLocationKey(parameters.getLocationKey())
.setContentKey(parameters.getContentKey()).setVersionKey(parameters.getVersionKey())
.setTTL(parameters.getTTL()).setHash(parameters.getHash());
// switch the content protection keys
rollbackParameters.setProtectionKeys(parameters.getNewProtectionKeys()).setNewProtectionKeys(
parameters.getProtectionKeys());
boolean success = dataManager.changeProtectionKey(rollbackParameters);
if (success) {
logger.debug("Rollback of change protection key succeeded. '{}'", parameters.toString());
setRequiresRollback(false);
} else {
throw new ProcessRollbackException(this, String.format(
"Rollback of change protection key failed. Remove failed. Parameters; '%s'", parameters.toString()));
}
return null;
}
}
```
|
```package org.hive2hive.core.events;
import static org.junit.Assert.assertEquals;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import net.engio.mbassy.listener.Handler;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.events.framework.interfaces.IUserEventListener;
import org.hive2hive.core.events.framework.interfaces.user.IUserLoginEvent;
import org.hive2hive.core.events.framework.interfaces.user.IUserLogoutEvent;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.exceptions.NoSessionException;
import org.hive2hive.core.network.NetworkManager;
import org.hive2hive.core.security.UserCredentials;
import org.hive2hive.core.utils.NetworkTestUtil;
import org.hive2hive.core.utils.UseCaseTestUtil;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public class UserEventsTest extends H2HJUnitTest {
@BeforeClass
public static void initTest() throws Exception {
testClass = UserEventsTest.class;
beforeClass();
}
@AfterClass
public static void endTest() {
afterClass();
}
@Test
public void loginLogoutEventTest() throws NoPeerConnectionException, NoSessionException, IOException {
List<NetworkManager> network = NetworkTestUtil.createNetwork(2);
// register an event listener at each node
TestUserEventListener listener0 = new TestUserEventListener();
network.get(0).getEventBus().subscribe(listener0);
TestUserEventListener listener1 = new TestUserEventListener();
network.get(1).getEventBus().subscribe(listener1);
UserCredentials credentials = generateRandomCredentials("username");
UseCaseTestUtil.register(credentials, network.get(0));
assertEquals(0, listener0.loginEvents.size());
assertEquals(0, listener1.loginEvents.size());
UseCaseTestUtil.login(credentials, network.get(0), tempFolder.newFolder());
// there should be still no event
assertEquals(0, listener0.loginEvents.size());
assertEquals(0, listener1.loginEvents.size());
UseCaseTestUtil.login(credentials, network.get(1), tempFolder.newFolder());
// the first client should now have a login event
assertEquals(1, listener0.loginEvents.size());
assertEquals("username", listener0.loginEvents.get(0).getCurrentUser());
assertEquals(network.get(1).getConnection().getPeer().peerAddress(), listener0.loginEvents.get(0).getClientAddress());
assertEquals(0, listener1.loginEvents.size());
UseCaseTestUtil.logout(network.get(0));
// the second client should now have a logout event
assertEquals(0, listener0.logoutEvents.size());
assertEquals(1, listener1.logoutEvents.size());
assertEquals("username", listener1.logoutEvents.get(0).getCurrentUser());
assertEquals(network.get(0).getConnection().getPeer().peerAddress(), listener1.logoutEvents.get(0)
.getClientAddress());
}
private class TestUserEventListener implements IUserEventListener {
final List<IUserLoginEvent> loginEvents = new ArrayList<IUserLoginEvent>();
final List<IUserLogoutEvent> logoutEvents = new ArrayList<IUserLogoutEvent>();
@Override
@Handler
public void onClientLogin(IUserLoginEvent loginEvent) {
loginEvents.add(loginEvent);
}
@Override
@Handler
public void onClientLogout(IUserLogoutEvent logoutEvent) {
logoutEvents.add(logoutEvent);
}
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.events.framework.abstracts;
import org.hive2hive.core.events.framework.interfaces.user.IUserEvent;
public class UserEvent implements IUserEvent {
private final String currentUser;
public UserEvent(String currentUser) {
this.currentUser = currentUser;
}
@Override
public String getCurrentUser() {
return currentUser;
}
}
```
|
```package org.hive2hive.core.security;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.bouncycastle.util.encoders.Base64;
import org.hive2hive.core.H2HJUnitTest;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public class HashUtilTest extends H2HJUnitTest {
@BeforeClass
public static void initTest() throws Exception {
testClass = HashUtilTest.class;
beforeClass();
}
@Test
public void hashDataTest() {
String data = randomString(1000);
byte[] hash = HashUtil.hash(data.getBytes());
assertNotNull(hash);
// assert that hashing twice results in the same hash
assertEquals(new String(hash), new String(HashUtil.hash(data.getBytes())));
// assert that different data is hashed to different hashes
String data2 = randomString(1000);
assertNotEquals(data, data2);
assertNotEquals(new String(hash), new String(HashUtil.hash(data2.getBytes())));
}
@Test
public void hashExampleDataTest() {
final String expected = "uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=";
String data = "hello world";
byte[] hash = HashUtil.hash(data.getBytes());
String result = new String(Base64.encode(hash));
assertEquals(expected, result);
}
@Test
public void hashStreamTest() throws IOException {
String data = randomString(5 * 1024);
File file = new File(System.getProperty("java.io.tmpdir"), randomString());
FileUtils.writeStringToFile(file, data);
byte[] hash = HashUtil.hash(file);
assertNotNull(hash);
// assert that hashing twice results in the same hash
assertEquals(new String(hash), new String(HashUtil.hash(file)));
// assert that different data is hashed to different hashes
String data2 = randomString(1000);
assertNotEquals(data, data2);
assertNotEquals(new String(hash), new String(HashUtil.hash(data2.getBytes())));
}
@Test
public void hashStreamExampleDataTest() throws IOException {
final String expected = "uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=";
String data = "hello world";
File file = new File(FileUtils.getTempDirectory(), randomString());
FileUtils.writeStringToFile(file, data);
byte[] hash = HashUtil.hash(file);
String result = new String(Base64.encode(hash));
assertEquals(expected, result);
}
@AfterClass
public static void endTest() throws Exception {
afterClass();
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.security;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Util for hashing and comparing hashes.
* TODO: this could be parameterized with the security provider for an optimal result
*
* @author Nico
* @author Chris
*
*/
public class HashUtil {
private static final Logger logger = LoggerFactory.getLogger(HashUtil.class);
private static final String HASH_ALGORITHM = "SHA-256";
private HashUtil() {
// only static methods
}
/**
* Generates a hash of a given data
*
* @param data to calculate the hash over it
* @return the hash
*/
public static byte[] hash(byte[] data) {
try {
MessageDigest digest = MessageDigest.getInstance(HASH_ALGORITHM);
digest.update(data, 0, data.length);
return digest.digest();
} catch (NoSuchAlgorithmException e) {
logger.error("Invalid hash algorithm {}", HASH_ALGORITHM, e);
return new byte[0];
}
}
/**
* Generates a hash of an input stream (can take a while)
*
* @param file the file to hash its contents
* @return the hash of the file
* @throws IOException if te file cannot be read
*/
public static byte[] hash(File file) throws IOException {
if (file == null) {
return new byte[0];
} else if (file.isDirectory()) {
return new byte[0];
} else if (!file.exists()) {
return new byte[0];
}
MessageDigest digest;
try {
digest = MessageDigest.getInstance(HASH_ALGORITHM);
} catch (NoSuchAlgorithmException e) {
logger.error("Invalid hash algorithm {}", HASH_ALGORITHM, e);
return new byte[0];
}
FileInputStream fis;
try {
// open the stream
fis = new FileInputStream(file);
} catch (FileNotFoundException e) {
logger.error("File {} not found to generate the hash", file, e);
return new byte[0];
}
DigestInputStream dis = new DigestInputStream(fis, digest);
try {
byte[] buffer = new byte[1024];
int numRead;
do {
numRead = dis.read(buffer);
} while (numRead != -1);
} finally {
if (dis != null) {
dis.close();
}
if (fis != null) {
fis.close();
}
}
return digest.digest();
}
/**
* Compares if the file hash matches a given hash
*
* @param file the file to comapre its hash
* @param expectedHash the expected hash of the file
* @return <code>true</code> if the file has the expected hash
* @throws IOException if the file cannot be read
*/
public static boolean compare(File file, byte[] expectedHash) throws IOException {
if (!file.exists() && (expectedHash == null || expectedHash.length == 0)) {
// both do not exist
return true;
} else if (file.isDirectory()) {
// directories always match
return true;
}
byte[] hash = HashUtil.hash(file);
return compare(hash, expectedHash);
}
/**
* Compares if the given hash matches another hash. This method works symmetrically and is not
* dependent on the parameter order
*
* @param actual the hash to test
* @param expected the expected hash
* @return <code>true</code> if the hashes match
*/
public static boolean compare(byte[] actual, byte[] expected) {
return Arrays.equals(actual, expected);
}
}
```
|
```package org.hive2hive.core.network.data;
import static org.junit.Assert.assertEquals;
import java.security.KeyPair;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.H2HTestData;
import org.hive2hive.core.exceptions.GetFailedException;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.model.UserPublicKey;
import org.hive2hive.core.network.NetworkManager;
import org.hive2hive.core.network.data.DataManager.H2HPutStatus;
import org.hive2hive.core.network.data.parameters.Parameters;
import org.hive2hive.core.utils.NetworkTestUtil;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* A test to check the {@link PublicKeyManager}.
*
* @author Seppi
* @author Nico
*/
public class PublicKeyManagerTest extends H2HJUnitTest {
private static List<NetworkManager> network;
private static Random random = new Random();
private PublicKeyManager publicKeyManager;
private KeyPair loggedInUserKeys;
private String loggedInUserId;
@BeforeClass
public static void initTest() throws Exception {
testClass = PublicKeyManagerTest.class;
beforeClass();
network = NetworkTestUtil.createNetwork(DEFAULT_NETWORK_SIZE);
}
@Before
public void createKeyManager() throws NoPeerConnectionException {
loggedInUserId = randomString();
loggedInUserKeys = generateRSAKeyPair(H2HConstants.KEYLENGTH_USER_KEYS);
KeyPair loggedInProtectionKeys = generateRSAKeyPair(H2HConstants.KEYLENGTH_PROTECTION);
NetworkManager node = NetworkTestUtil.getRandomNode(network);
publicKeyManager = new PublicKeyManager(loggedInUserId, loggedInUserKeys, loggedInProtectionKeys,
node.getDataManager());
}
@Test
public void testGettingLocalUserKeys() throws GetFailedException, NoPeerConnectionException {
// check if the public key manager returns correctly the key of the logged in user
assertEquals(loggedInUserKeys.getPublic(), publicKeyManager.getPublicKey(loggedInUserId));
}
@Test
public void testFetchingFromNetwork() throws GetFailedException, NoPeerConnectionException {
// create and upload some fake public keys into the network
Map<String, PublicKey> publicKeys = new HashMap<String, PublicKey>();
for (int i = 0; i < random.nextInt(10); i++) {
String userId = randomString();
KeyPair key = generateRSAKeyPair(H2HConstants.KEYLENGTH_USER_KEYS);
UserPublicKey userPublicKey = new UserPublicKey(key.getPublic());
Parameters parameters = new Parameters().setLocationKey(userId).setContentKey(H2HConstants.USER_PUBLIC_KEY)
.setNetworkContent(userPublicKey);
Assert.assertEquals(H2HPutStatus.OK, NetworkTestUtil.getRandomNode(network).getDataManager().put(parameters));
publicKeys.put(userId, key.getPublic());
}
// check if the public key manager correctly fetches all public keys
for (String userId : publicKeys.keySet()) {
assertEquals(publicKeys.get(userId), publicKeyManager.getPublicKey(userId));
}
}
@Test
public void testCachingOfPublicKeys() throws GetFailedException, NoPeerConnectionException {
Map<String, PublicKey> publicKeys = new HashMap<String, PublicKey>();
for (int i = 0; i < random.nextInt(5); i++) {
String userId = randomString();
KeyPair key = generateRSAKeyPair(H2HConstants.KEYLENGTH_USER_KEYS);
UserPublicKey userPublicKey = new UserPublicKey(key.getPublic());
Parameters parameters = new Parameters().setLocationKey(userId).setContentKey(H2HConstants.USER_PUBLIC_KEY)
.setNetworkContent(userPublicKey);
Assert.assertEquals(H2HPutStatus.OK, NetworkTestUtil.getRandomNode(network).getDataManager().put(parameters));
publicKeys.put(userId, key.getPublic());
}
for (String userId : publicKeys.keySet()) {
assertEquals(publicKeys.get(userId), publicKeyManager.getPublicKey(userId));
// remove the public keys from network, the manager shouldn't do any get request
Parameters parameters = new Parameters().setLocationKey(userId).setContentKey(H2HConstants.USER_PUBLIC_KEY);
NetworkTestUtil.getRandomNode(network).getDataManager().removeUnblocked(parameters).awaitUninterruptibly();
// the public key manager should use his cache
assertEquals(publicKeys.get(userId), publicKeyManager.getPublicKey(userId));
}
}
@Test(expected = GetFailedException.class)
public void testNonExistingPublicKey() throws GetFailedException {
String nonExistingUserId = randomString();
publicKeyManager.getPublicKey(nonExistingUserId);
}
@Test(expected = GetFailedException.class)
public void testGetFailedExceptions() throws NoPeerConnectionException, GetFailedException {
String otherUser = randomString();
H2HTestData noPublicKey = new H2HTestData("public key");
Parameters parameters = new Parameters().setLocationKey(otherUser).setContentKey(H2HConstants.USER_PUBLIC_KEY)
.setNetworkContent(noPublicKey);
Assert.assertEquals(H2HPutStatus.OK, NetworkTestUtil.getRandomNode(network).getDataManager().put(parameters));
publicKeyManager.getPublicKey(otherUser);
}
@Test
public void testAllMixed() throws GetFailedException, NoPeerConnectionException {
// create and upload some fake public keys into the network
Map<String, PublicKey> publicKeys = new HashMap<String, PublicKey>();
for (int i = 0; i < 5; i++) {
String userId = randomString();
KeyPair key = generateRSAKeyPair(H2HConstants.KEYLENGTH_USER_KEYS);
UserPublicKey userPublicKey = new UserPublicKey(key.getPublic());
Parameters parameters = new Parameters().setLocationKey(userId).setContentKey(H2HConstants.USER_PUBLIC_KEY)
.setNetworkContent(userPublicKey);
Assert.assertEquals(H2HPutStatus.OK, NetworkTestUtil.getRandomNode(network).getDataManager().put(parameters));
publicKeys.put(userId, key.getPublic());
}
// check if the public key manager correctly fetches all public keys
List<String> userIds = new ArrayList<String>(publicKeys.keySet());
List<String> gettingList = new ArrayList<String>();
for (int i = 0; i < 20; i++) {
gettingList.add(userIds.get(random.nextInt(userIds.size())));
}
// get several times the public key
for (String userId : gettingList) {
assertEquals(publicKeys.get(userId), publicKeyManager.getPublicKey(userId));
}
}
@AfterClass
public static void cleanAfterClass() {
NetworkTestUtil.shutdownNetwork(network);
afterClass();
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.network.data;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.exceptions.GetFailedException;
import org.hive2hive.core.model.BaseNetworkContent;
import org.hive2hive.core.model.UserPublicKey;
import org.hive2hive.core.model.versioned.Locations;
import org.hive2hive.core.network.data.parameters.IParameters;
import org.hive2hive.core.network.data.parameters.Parameters;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A caching public key manager, which if necessary gets the desired public key of an user from the network.
*
* @author Seppi, Nico
*/
public class PublicKeyManager {
private static final Logger logger = LoggerFactory.getLogger(PublicKeyManager.class);
private final String userId;
// the user's encryption key pair (e.g. for sending direct messages)
private final KeyPair usersKeyPair;
// the default authentication keys for signing (e.g. locations, unshared files, ..)
private final KeyPair defaultProtectionKeyPair;
private final DataManager dataManager;
private final Map<String, PublicKey> publicKeyCache;
public PublicKeyManager(String userId, KeyPair usersKeyPair, KeyPair defaultProtectionKeyPair, DataManager dataManager) {
this.userId = userId;
this.usersKeyPair = usersKeyPair;
this.defaultProtectionKeyPair = defaultProtectionKeyPair;
this.dataManager = dataManager;
this.publicKeyCache = new ConcurrentHashMap<String, PublicKey>();
}
/**
* @return the public key of the currently logged in user.
*/
public PublicKey getOwnPublicKey() {
return usersKeyPair.getPublic();
}
/**
* @return the private key of the currently logged in user
*/
public PrivateKey getOwnPrivateKey() {
return usersKeyPair.getPrivate();
}
/**
* @return the users key pair
*/
public KeyPair getOwnKeyPair() {
return usersKeyPair;
}
/**
* @return the protection keys for e.g. the {@link Locations}.
*/
public KeyPair getDefaultProtectionKeyPair() {
return defaultProtectionKeyPair;
}
/**
* @return a copy of all cached public keys
*/
public Map<String, PublicKey> getCachedPublicKeys() {
return Collections.unmodifiableMap(publicKeyCache);
}
public void putPublicKey(String userId, PublicKey publicKey) {
publicKeyCache.put(userId, publicKey);
}
public boolean containsPublicKey(String userId) {
return publicKeyCache.containsKey(userId);
}
/**
* Gets the public key. If not in cache the method fetches the desired public key from network. In this
* case the call blocks.
*
* @param userId the unique id of the user
* @return the public key of the user
* @throws GetFailedException if the public key can't be fetched
*/
public PublicKey getPublicKey(String userId) throws GetFailedException {
logger.debug("Requested to get the public key of user '{}'.", userId);
if (this.userId.equals(userId)) {
// get the own public key
return usersKeyPair.getPublic();
}
if (publicKeyCache.containsKey(userId)) {
// check the cache
return publicKeyCache.get(userId);
}
IParameters parameters = new Parameters().setLocationKey(userId).setContentKey(H2HConstants.USER_PUBLIC_KEY);
BaseNetworkContent content = dataManager.get(parameters);
return evaluateResult(content, userId);
}
private PublicKey evaluateResult(BaseNetworkContent content, String requestingUserId) throws GetFailedException {
if (content == null) {
logger.warn("Did not find the public key of user '{}'.", requestingUserId);
throw new GetFailedException("No public key found.");
} else if (!(content instanceof UserPublicKey)) {
logger.error("The received content is not a user public key. Did not find the public key of user '{}'.",
requestingUserId);
throw new GetFailedException("Received unkown content.");
} else {
logger.trace("Successfully received the public key of user '{}'.", requestingUserId);
UserPublicKey userPublicKey = (UserPublicKey) content;
if (userPublicKey.getPublicKey() == null) {
logger.error("User public key of user '{}' is corrupted.", requestingUserId);
throw new GetFailedException("Received corrupted public key.");
} else {
logger.debug("Successfully got the public key of user '{}'.", userId);
// store it in the cache
publicKeyCache.put(requestingUserId, userPublicKey.getPublicKey());
// return it
return userPublicKey.getPublicKey();
}
}
}
}
```
|
```package org.hive2hive.core.utils;
import java.math.BigInteger;
import org.hive2hive.core.api.interfaces.IFileConfiguration;
/**
* File configuration for fast test execution
*
* @author Nico
*
*/
public class TestFileConfiguration implements IFileConfiguration {
// for fast access
public static int CHUNK_SIZE = 64;
@Override
public BigInteger getMaxFileSize() {
return BigInteger.valueOf(getChunkSize() * 5);
}
@Override
public int getMaxNumOfVersions() {
return 5;
}
@Override
public BigInteger getMaxSizeAllVersions() {
return BigInteger.valueOf(getMaxNumOfVersions() * getChunkSize());
}
@Override
public int getChunkSize() {
return CHUNK_SIZE;
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.api.configs;
import java.math.BigInteger;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.api.interfaces.IFileConfiguration;
/**
* A file configuration such that the peers know how to handle file uploads, chunking and cleanups. This
* configuration must be constant for all peers in the DHT.
*
* @author Nico
*
*/
public class FileConfiguration implements IFileConfiguration {
private final BigInteger maxFileSize;
private final int maxNumOfVersions;
private final BigInteger maxSizeOfAllVersions;
private final int chunkSize;
private FileConfiguration(BigInteger maxFileSize, int maxNumOfVersions, BigInteger maxSizeAllVersions, int chunkSize) {
assert maxFileSize.signum() == 1;
assert maxNumOfVersions > 0;
assert maxSizeAllVersions.signum() == 1;
assert chunkSize > 0;
this.maxFileSize = maxFileSize;
this.maxNumOfVersions = maxNumOfVersions;
this.maxSizeOfAllVersions = maxSizeAllVersions;
this.chunkSize = chunkSize;
}
/**
* Creates a default file configuration
*
* @return the file configuration
*/
public static IFileConfiguration createDefault() {
return new FileConfiguration(H2HConstants.DEFAULT_MAX_FILE_SIZE, H2HConstants.DEFAULT_MAX_NUM_OF_VERSIONS,
H2HConstants.DEFAULT_MAX_SIZE_OF_ALL_VERSIONS, H2HConstants.DEFAULT_CHUNK_SIZE);
}
/**
* Create a file configuration with the given parameters
*
* @param maxFileSize the maximum file size (in bytes)
* @param maxNumOfVersions the allowed number of versions
* @param maxSizeAllVersions the maximum file size when summing up all versions (in bytes)
* @param chunkSize the size of a chunk (in bytes)
* @return the created configuration
*/
public static IFileConfiguration createCustom(BigInteger maxFileSize, int maxNumOfVersions,
BigInteger maxSizeAllVersions, int chunkSize) {
return new FileConfiguration(maxFileSize, maxNumOfVersions, maxSizeAllVersions, chunkSize);
}
@Override
public BigInteger getMaxFileSize() {
return maxFileSize;
}
@Override
public int getMaxNumOfVersions() {
return maxNumOfVersions;
}
@Override
public BigInteger getMaxSizeAllVersions() {
return maxSizeOfAllVersions;
}
@Override
public int getChunkSize() {
return chunkSize;
}
}
```
|
```package org.hive2hive.core.security;
import io.netty.buffer.ByteBuf;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.Signature;
import java.security.SignatureException;
import net.tomp2p.connection.SignatureFactory;
import net.tomp2p.message.SignatureCodec;
import net.tomp2p.storage.Data;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.H2HJUnitTest;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
public class H2HSignatureFactoryTest extends H2HJUnitTest {
private static KeyPair protectionKey;
private static Data testData;
@BeforeClass
public static void initTest() throws Exception {
// create a content protection key
protectionKey = generateRSAKeyPair(H2HConstants.KEYLENGTH_PROTECTION);
// generate some test data
testData = new Data("test");
testClass = H2HSignatureFactoryTest.class;
beforeClass();
}
@Test
public void testSignVerify() throws InvalidKeyException, SignatureException, IOException {
SignatureFactory signatureFactory = new H2HSignatureFactory();
// sign the data
SignatureCodec signature = signatureFactory.sign(protectionKey.getPrivate(), testData.buffer().nioBuffers());
// verify the data with the signature
Assert.assertTrue(signatureFactory.verify(protectionKey.getPublic(), testData.buffer().nioBuffers(), signature));
}
@Test
public void testUpdateSingle() throws InvalidKeyException, SignatureException, IOException {
// sign the data
SignatureCodec signatureCodec = new H2HSignatureFactory().sign(protectionKey.getPrivate(), testData.buffer()
.nioBuffers());
// update (already belongs to the verification)
Signature signature = new H2HSignatureFactory().update(protectionKey.getPublic(), testData.toByteBuffers());
// verify the data with the signature
Assert.assertTrue(signature.verify(signatureCodec.encode()));
}
@Test
public void testUpdateMultiple() throws InvalidKeyException, SignatureException, IOException {
// sign the data
SignatureCodec signatureCodec = new H2HSignatureFactory().sign(protectionKey.getPrivate(), testData.buffer()
.nioBuffers());
// update (already belongs to the verification)
int length = testData.buffer().readableBytes();
ByteBuf slice1 = testData.buffer().copy(0, 3);
ByteBuf slice2 = testData.buffer().copy(3, 4);
ByteBuf slice3 = testData.buffer().copy(7, length - 7);
H2HSignatureFactory signatureFactory = new H2HSignatureFactory();
Signature signature = signatureFactory.update(protectionKey.getPublic(), slice1.nioBuffers());
signature.update(slice2.array());
signature.update(slice3.array());
// verify the data with the signature
Assert.assertTrue(signature.verify(signatureCodec.encode()));
}
@AfterClass
public static void cleanAfterClass() {
afterClass();
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.security;
import io.netty.buffer.ByteBuf;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import net.tomp2p.connection.SignatureFactory;
import net.tomp2p.message.SignatureCodec;
import net.tomp2p.p2p.PeerBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* The signature is done with SHA1withRSA.
*
* @author Seppi
* @author Nico
*/
public class H2HSignatureFactory implements SignatureFactory {
private static final long serialVersionUID = -8522085229948986395L;
private static final Logger logger = LoggerFactory.getLogger(H2HSignatureFactory.class);
/**
* @return The signature mechanism
*/
private Signature signatureInstance() {
try {
return Signature.getInstance("SHA1withRSA");
} catch (NoSuchAlgorithmException e) {
logger.error("Could not find signature algorithm:", e);
return null;
}
}
@Override
public PublicKey decodePublicKey(final byte[] me) {
X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(me);
try {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return keyFactory.generatePublic(pubKeySpec);
} catch (NoSuchAlgorithmException e) {
logger.error("Could not find decoding algorithm:", e);
return null;
} catch (InvalidKeySpecException e) {
logger.error("Invalid key specs provided:", e);
return null;
}
}
// decodes with header
@Override
public PublicKey decodePublicKey(ByteBuf buf) {
if (buf.readableBytes() < 2) {
return null;
}
int len = buf.getUnsignedShort(buf.readerIndex());
if (buf.readableBytes() - 2 < len) {
return null;
}
buf.skipBytes(2);
if (len <= 0) {
return PeerBuilder.EMPTY_PUBLIC_KEY;
}
byte[] me = new byte[len];
buf.readBytes(me);
return decodePublicKey(me);
}
@Override
public void encodePublicKey(PublicKey publicKey, ByteBuf buf) {
byte[] data = publicKey.getEncoded();
buf.writeShort(data.length);
buf.writeBytes(data);
}
@Override
public SignatureCodec sign(PrivateKey privateKey, ByteBuffer[] byteBuffers) throws InvalidKeyException,
SignatureException, IOException {
Signature signature = signatureInstance();
signature.initSign(privateKey);
int len = byteBuffers.length;
for (int i = 0; i < len; i++) {
ByteBuffer buffer = byteBuffers[i];
signature.update(buffer);
}
byte[] signatureData = signature.sign();
SignatureCodec decodedSignature = new H2HSignatureCodec(signatureData);
return decodedSignature;
}
@Override
public boolean verify(PublicKey publicKey, ByteBuffer[] byteBuffers, SignatureCodec signatureCodec)
throws SignatureException, InvalidKeyException {
Signature signature = signatureInstance();
signature.initVerify(publicKey);
int len = byteBuffers.length;
for (int i = 0; i < len; i++) {
ByteBuffer buffer = byteBuffers[i];
signature.update(buffer);
}
byte[] signatureReceived = signatureCodec.encode();
return signature.verify(signatureReceived);
}
@Override
public Signature update(PublicKey receivedPublicKey, ByteBuffer[] byteBuffers) throws InvalidKeyException,
SignatureException {
Signature signature = signatureInstance();
signature.initVerify(receivedPublicKey);
int arrayLength = byteBuffers.length;
for (int i = 0; i < arrayLength; i++) {
signature.update(byteBuffers[i]);
}
return signature;
}
@Override
public SignatureCodec signatureCodec(ByteBuf buf) {
return new H2HSignatureCodec(buf);
}
@Override
public int signatureSize() {
return H2HSignatureCodec.SIGNATURE_SIZE;
}
}
```
|
```package org.hive2hive.core.model.versioned;
import java.security.KeyPair;
import java.util.ArrayList;
import java.util.List;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.model.FileVersion;
import org.hive2hive.core.model.MetaChunk;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
public class MetaFileSmallTest extends H2HJUnitTest {
private static KeyPair keys;
@BeforeClass
public static void initTest() throws Exception {
testClass = MetaFileSmallTest.class;
beforeClass();
keys = generateRSAKeyPair(H2HConstants.KEYLENGTH_META_FILE);
}
@Test
public void testGetNewestVersion() {
List<FileVersion> versions = new ArrayList<FileVersion>();
versions.add(new FileVersion(0, 123, System.currentTimeMillis(), new ArrayList<MetaChunk>()));
versions.add(new FileVersion(1, 123, System.currentTimeMillis(), new ArrayList<MetaChunk>()));
// timestamp is older
versions.add(new FileVersion(2, 123, System.currentTimeMillis() - 1000 * 60, new ArrayList<MetaChunk>()));
MetaFileSmall metaFileSmall = new MetaFileSmall(keys.getPublic(), versions, keys);
FileVersion newestVersion = metaFileSmall.getNewestVersion();
Assert.assertEquals(2, newestVersion.getIndex());
}
@Test
public void testGetVersionByIndex() {
FileVersion v0 = new FileVersion(0, 1213, 100, new ArrayList<MetaChunk>());
FileVersion v1 = new FileVersion(1, 312, 1000, new ArrayList<MetaChunk>());
// timestamp is older
FileVersion v2 = new FileVersion(2, 213, 999, new ArrayList<MetaChunk>());
List<FileVersion> versions = new ArrayList<FileVersion>();
versions.add(v0);
versions.add(v1);
versions.add(v2);
MetaFileSmall metaFileSmall = new MetaFileSmall(keys.getPublic(), versions, keys);
Assert.assertEquals(v0, metaFileSmall.getVersionByIndex(0));
Assert.assertEquals(v1, metaFileSmall.getVersionByIndex(1));
Assert.assertEquals(v2, metaFileSmall.getVersionByIndex(2));
}
@Test
public void testGetTotalSize() {
List<FileVersion> versions = new ArrayList<FileVersion>();
versions.add(new FileVersion(0, 4, 0, new ArrayList<MetaChunk>()));
versions.add(new FileVersion(1, 10, 1, new ArrayList<MetaChunk>()));
versions.add(new FileVersion(2, 1000, 2, new ArrayList<MetaChunk>()));
MetaFileSmall metaFileSmall = new MetaFileSmall(keys.getPublic(), versions, keys);
Assert.assertEquals(4 + 10 + 1000, metaFileSmall.getTotalSize().intValue());
}
@AfterClass
public static void cleanAfterClass() {
afterClass();
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.model.versioned;
import java.math.BigInteger;
import java.security.KeyPair;
import java.security.PublicKey;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.hive2hive.core.model.FileVersion;
/**
* Holds meta data of a small file in the DHT
*
* @author Nico, Seppi
*/
public class MetaFileSmall extends BaseMetaFile {
private static final long serialVersionUID = -3385321499412137545L;
private final List<FileVersion> versions;
private final KeyPair chunkKey;
public MetaFileSmall(PublicKey id, List<FileVersion> versions, KeyPair chunkKey) {
super(id, true);
this.versions = versions;
this.chunkKey = chunkKey;
}
public List<FileVersion> getVersions() {
return versions;
}
public KeyPair getChunkKey() {
return chunkKey;
}
public BigInteger getTotalSize() {
if (versions == null) {
return BigInteger.ZERO;
} else {
BigInteger sum = BigInteger.ZERO;
for (FileVersion version : versions) {
sum = sum.add(version.getSize());
}
return sum;
}
}
public FileVersion getNewestVersion() {
if (versions == null || versions.isEmpty()) {
return null;
}
return Collections.max(versions, new Comparator<FileVersion>() {
@Override
public int compare(FileVersion o1, FileVersion o2) {
return new Integer(o1.getIndex()).compareTo(o2.getIndex());
}
});
}
public FileVersion getVersionByIndex(int index) {
if (versions == null || versions.isEmpty()) {
return null;
}
for (FileVersion version : versions) {
if (version.getIndex() == index) {
return version;
}
}
return null;
}
}
```
|
```package org.hive2hive.core.file;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.network.data.PublicKeyManager;
import org.hive2hive.core.security.EncryptionUtil.RSA_KEYLENGTH;
import org.hive2hive.core.serializer.FSTSerializer;
import org.hive2hive.core.utils.helper.TestFileAgent;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* Test the {@link FileUtil} used for the H2H node.
*
* @author Nico
*
*/
public class FileUtilTest extends H2HJUnitTest {
private static FSTSerializer serializer;
private TestFileAgent fileAgent;
@BeforeClass
public static void initTest() throws Exception {
testClass = FileUtilTest.class;
beforeClass();
serializer = new FSTSerializer();
}
@AfterClass
public static void cleanAfterClass() {
afterClass();
}
@Before
public void createRoot() throws IOException {
fileAgent = new TestFileAgent();
}
@Test
public void testReadWriteMetaData() throws IOException, ClassNotFoundException {
PublicKeyManager publicKeyManager = new PublicKeyManager("user", generateRSAKeyPair(RSA_KEYLENGTH.BIT_512),
generateRSAKeyPair(RSA_KEYLENGTH.BIT_512), null);
FileUtil.writePersistentMetaData(fileAgent, publicKeyManager, serializer);
PersistentMetaData persistentMetaData = FileUtil.readPersistentMetaData(fileAgent, serializer);
Assert.assertNotNull(persistentMetaData);
Assert.assertEquals(0, persistentMetaData.getPublicKeyCache().size());
}
@Test
public void testSortPreorder() {
List<File> files = new ArrayList<File>();
File aaa = new File("/aaa");
files.add(aaa);
File bbb = new File("/bbb");
files.add(bbb);
File c = new File(aaa, "c.txt");
files.add(c);
File d = new File("/bzz", "d.txt");
files.add(d);
File bzz = new File("/bzz");
files.add(bzz);
FileUtil.sortPreorder(files);
int index = 0;
Assert.assertEquals(aaa, files.get(index++));
Assert.assertEquals(c, files.get(index++));
Assert.assertEquals(bbb, files.get(index++));
Assert.assertEquals(bzz, files.get(index++));
Assert.assertEquals(d, files.get(index++));
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.file;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.network.data.PublicKeyManager;
import org.hive2hive.core.serializer.IH2HSerialize;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class FileUtil {
private static final Logger logger = LoggerFactory.getLogger(FileUtil.class);
private FileUtil() {
// only static methods
}
/**
* Writes the meta data (used to synchronize) to the disk
*
* @param fileAgent the file agent
* @param keyManager the key manager
* @param serializer the serializer to use
* @throws IOException if the data cannot be serialized or stored
*/
public static void writePersistentMetaData(IFileAgent fileAgent, PublicKeyManager keyManager, IH2HSerialize serializer)
throws IOException {
// generate the new persistent meta data
PersistentMetaData metaData = new PersistentMetaData();
// add the public keys
if (keyManager != null) {
metaData.setPublicKeyCache(keyManager.getCachedPublicKeys());
}
byte[] encoded = serializer.serialize(metaData);
fileAgent.writeCache(H2HConstants.META_FILE_NAME, encoded);
}
/**
* Reads the meta data (used to synchronize) from the disk
*
* @param fileAgent the file agent
* @param serializer the serializer to use
* @return the read meta data (never null)
*/
public static PersistentMetaData readPersistentMetaData(IFileAgent fileAgent, IH2HSerialize serializer) {
try {
byte[] content = fileAgent.readCache(H2HConstants.META_FILE_NAME);
if (content == null || content.length == 0) {
logger.warn("Not found the meta data. Create new one");
return new PersistentMetaData();
}
return (PersistentMetaData) serializer.deserialize(content);
} catch (IOException | ClassNotFoundException e) {
logger.error("Cannot deserialize meta data. Reason: {}", e.getMessage());
return new PersistentMetaData();
}
}
/**
* Returns the file separator of the operating system
*
* @return the file separator of the current operating system
*/
public static String getFileSep() {
return System.getProperty("file.separator");
}
/**
* Makes a file path relative to the base
*
* @param base the base file
* @param child the child file
* @return the relative file
*/
public static File relativize(File base, File child) {
return new File(base.toURI().relativize(child.toURI()).getPath());
}
/**
* Note that file.length can be very slowly (see
* http://stackoverflow.com/questions/116574/java-get-file-size-efficiently)
*
* @param file the file to determine the size
* @return the file size in bytes
*/
public static long getFileSize(File file) {
InputStream stream = null;
try {
URL url = file.toURI().toURL();
stream = url.openStream();
return stream.available();
} catch (IOException e) {
// just make it the traditional way
return file.length();
} finally {
try {
if (stream != null) {
stream.close();
}
} catch (IOException e) {
// ignore
}
}
}
/**
* Checks whether the given file is in the given H2H root folder (note, the user must be logged in).
*
* @param file the file to test
* @param root the current root
* @return true when the file is within the H2H directory, otherwise false
*/
public static boolean isInH2HDirectory(File file, File root) {
if (root == null || file == null) {
return false;
}
return file.getAbsolutePath().toString().startsWith(root.getAbsolutePath());
}
/**
* Does the same as {@link #isInH2HDirectory(File, File)} but taking a session as parameter
*
* @param fileAgent the file agent
* @param file the file to check
* @return whether the file is in the managed directory
*/
public static boolean isInH2HDirectory(IFileAgent fileAgent, File file) {
return fileAgent == null ? false : isInH2HDirectory(file, fileAgent.getRoot());
}
/**
* Sorts the given list in pre-order style.
*
* @param unsortedFiles a list of unsorted file. The list will be updated.
*/
public static void sortPreorder(List<File> unsortedFiles) {
Collections.sort(unsortedFiles, new Comparator<File>() {
@Override
public int compare(File o1, File o2) {
return o1.getAbsolutePath().compareTo(o2.getAbsolutePath());
}
});
}
}
```
|
```package org.hive2hive.client.util.buffer;
import java.io.File;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.commons.io.FileUtils;
import org.junit.Assert;
import org.junit.Test;
/**
* Test the buffer
*
* @author Nico
*
*/
public class BaseFileBufferTest {
@Test
public void testBufferFinishesSomewhen() throws IOException, InterruptedException {
final AtomicInteger counter = new AtomicInteger(0);
BaseFileBuffer buffer = new BaseFileBuffer(null) {
@Override
protected void processBuffer(IFileBufferHolder buffer) {
counter.set(buffer.getFileBuffer().size());
}
};
File directory = new File(FileUtils.getTempDirectory(), UUID.randomUUID().toString());
buffer.addFileToBuffer(directory);
buffer.addFileToBuffer(createFileRandomContent(directory));
// sleep for some time
Thread.sleep((long) (IFileBuffer.BUFFER_WAIT_TIME_MS * 1.5));
// added two files, buffer should contain two files too
Assert.assertEquals(2, counter.get());
}
@Test
public void testBufferRunsInBatches() throws IOException, InterruptedException {
final AtomicInteger counter = new AtomicInteger(0);
BaseFileBuffer buffer = new BaseFileBuffer(null) {
@Override
protected void processBuffer(IFileBufferHolder buffer) {
counter.addAndGet(buffer.getFileBuffer().size());
}
};
File directory = new File(FileUtils.getTempDirectory(), UUID.randomUUID().toString());
buffer.addFileToBuffer(directory);
buffer.addFileToBuffer(createFileRandomContent(directory));
// sleep for some time
Thread.sleep((long) (IFileBuffer.BUFFER_WAIT_TIME_MS * 1.4));
// add another file
buffer.addFileToBuffer(createFileRandomContent(directory));
// although it's same buffer, should still be 2
Assert.assertEquals(2, counter.get());
// reset to 0
counter.set(0);
// wait for the next batch
Thread.sleep((long) (IFileBuffer.BUFFER_WAIT_TIME_MS * 1.4));
Assert.assertEquals(1, counter.get());
}
public static File createFileRandomContent(File parent) throws IOException {
// create file of size of multiple numbers of chunks
File file = new File(parent, UUID.randomUUID().toString());
FileUtils.write(file, UUID.randomUUID().toString(), true);
return file;
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.client.util.buffer;
import java.io.File;
import java.util.Timer;
import java.util.TimerTask;
import org.hive2hive.core.api.interfaces.IFileManager;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.exceptions.NoSessionException;
import org.hive2hive.core.processes.files.list.FileNode;
import org.hive2hive.processframework.exceptions.InvalidProcessStateException;
import org.hive2hive.processframework.exceptions.ProcessExecutionException;
import org.hive2hive.processframework.interfaces.IProcessComponent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class BaseFileBuffer implements IFileBuffer {
private static final Logger logger = LoggerFactory.getLogger(BaseFileBuffer.class);
protected final IFileManager fileManager;
protected FileBufferHolder currentBuffer;
protected BaseFileBuffer(IFileManager fileManager) {
this.fileManager = fileManager;
}
@Override
public final synchronized void addFileToBuffer(File file) {
if (currentBuffer == null) {
currentBuffer = new FileBufferHolder();
startBuffering(currentBuffer);
}
currentBuffer.addFile(file);
}
private void startBuffering(final FileBufferHolder fileBuffer) {
logger.debug("Start buffering for {} ms.", IFileBuffer.BUFFER_WAIT_TIME_MS);
new Timer().schedule(new TimerTask() {
@Override
public void run() {
currentBuffer = null;
logger.debug("Finished buffering. {} file(s) in buffer.", fileBuffer.getFileBuffer().size());
fileBuffer.awaitReady();
processBuffer(fileBuffer);
}
}, BUFFER_WAIT_TIME_MS);
// start getting the file list
new Thread(new FileListRunnable(fileBuffer)).start();
}
/**
* Process the files in the buffer after the buffering time exceeded.
*
* @param buffer the buffer holder
*/
protected abstract void processBuffer(IFileBufferHolder buffer);
private class FileListRunnable implements Runnable {
private final FileBufferHolder fileBuffer;
public FileListRunnable(FileBufferHolder fileBuffer) {
this.fileBuffer = fileBuffer;
}
@Override
public void run() {
// skip the file list
if (fileManager == null) {
fileBuffer.setSyncFiles(null);
fileBuffer.setReady();
return;
}
IProcessComponent<FileNode> fileList = null;
try {
fileList = fileManager.createFileListProcess();
} catch (NoPeerConnectionException | NoSessionException e) {
logger.error("Could not get the file list.", e);
fileBuffer.setSyncFiles(null);
fileBuffer.setReady();
return;
}
// execute process synchronously
try {
fileBuffer.setSyncFiles(fileList.execute());
fileBuffer.setReady();
} catch (InvalidProcessStateException ex) {
logger.error("Could not launch the process to get the file list.", ex);
} catch (ProcessExecutionException ex) {
logger.error("Process execution to get the file list failed.", ex);
}
}
}
}
```
|
```package org.hive2hive.core.extras;
import java.io.File;
import java.io.IOException;
import java.security.KeyPair;
import java.util.List;
import java.util.Map;
import org.apache.commons.io.FileUtils;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.model.FileIndex;
import org.hive2hive.core.model.FolderIndex;
import org.hive2hive.core.model.Index;
import org.hive2hive.core.model.versioned.UserProfile;
import org.hive2hive.core.security.EncryptionUtil.RSA_KEYLENGTH;
import org.hive2hive.core.security.HashUtil;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
public class FileSynchronizerTest extends H2HJUnitTest {
private File rootFile;
private FolderIndex root;
private FileIndex node1f1;
private FileIndex node1f2;
private FolderIndex node1d;
private FileIndex node2f;
private Index node2d;
private File file1f1;
private File file1f2;
private File file1d;
private File file2f;
private File file2d;
private UserProfile userProfile;
@BeforeClass
public static void initTest() throws Exception {
testClass = FileSynchronizerTest.class;
beforeClass();
}
@AfterClass
public static void cleanAfterClass() {
afterClass();
}
@Before
public void createTreeNode() throws IOException {
rootFile = tempFolder.newFolder();
// naming convention:
// [number][type][index] where number is the level and type is either 'f' for file or 'd' for
// directory. The index is to distinct two files/folders on the same level
// setup is like
// root:
// - 1f1
// - 1f2
// - 1d:
// - - 2f
// - - 2d (empty folder)
file1f1 = new File(rootFile, "1f1");
FileUtils.writeStringToFile(file1f1, randomString());
file1f2 = new File(rootFile, "1f2");
FileUtils.writeStringToFile(file1f2, randomString());
file1d = new File(rootFile, "1d");
file1d.mkdirs();
file2f = new File(file1d, "2f");
FileUtils.writeStringToFile(file2f, randomString());
file2d = new File(file1d, "2d");
file2d.mkdir();
KeyPair keys = generateRSAKeyPair(RSA_KEYLENGTH.BIT_512);
userProfile = new UserProfile("test-user", keys, keys);
root = userProfile.getRoot();
node1f1 = new FileIndex(root, keys, "1f1", HashUtil.hash(file1f1));
node1f2 = new FileIndex(root, keys, "1f2", HashUtil.hash(file1f2));
node1d = new FolderIndex(root, keys, "1d");
node2f = new FileIndex(node1d, keys, "2f", HashUtil.hash(file2f));
node2d = new FolderIndex(node1d, keys, "2d");
}
@Test
public void testDeletedLocally() throws IOException, ClassNotFoundException {
Map<String, byte[]> before = FileSynchronizer.visitFiles(rootFile);
file1f1.delete();
file2d.delete();
Map<String, byte[]> after = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, before, after);
List<Index> deletedLocally = fileSynchronizer.getDeletedLocally();
Assert.assertEquals(2, deletedLocally.size());
Assert.assertTrue(deletedLocally.contains(node1f1));
Assert.assertTrue(deletedLocally.contains(node2d));
}
@Test
public void testDeletedRemotely() throws IOException, ClassNotFoundException {
Map<String, byte[]> before = FileSynchronizer.visitFiles(rootFile);
root.removeChild(node1f1);
root.removeChild(node1d); // delete whole directory
Map<String, byte[]> after = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, before, after);
List<File> deletedRemotely = fileSynchronizer.getDeletedRemotely();
Assert.assertEquals(4, deletedRemotely.size());
Assert.assertTrue(deletedRemotely.contains(file1f1));
Assert.assertTrue(deletedRemotely.contains(file1d));
Assert.assertTrue(deletedRemotely.contains(file2f));
Assert.assertTrue(deletedRemotely.contains(file2d));
}
@Test
public void testAddedLocally() throws IOException, ClassNotFoundException {
Map<String, byte[]> before = FileSynchronizer.visitFiles(rootFile);
// one folder
File file2d2 = new File(file1d, "2d2");
file2d2.mkdir();
// one file
File file1f3 = new File(rootFile, "1f3");
FileUtils.writeStringToFile(file1f3, randomString());
Map<String, byte[]> after = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, before, after);
List<File> addedLocally = fileSynchronizer.getAddedLocally();
Assert.assertEquals(2, addedLocally.size());
Assert.assertTrue(addedLocally.contains(file2d2));
Assert.assertTrue(addedLocally.contains(file1f3));
}
@Test
public void testAddedRemotely() throws IOException, ClassNotFoundException {
KeyPair keys = generateRSAKeyPair(H2HConstants.KEYLENGTH_META_FILE);
Index node1f3 = new FileIndex(root, keys, "1f3", null);
Index node2d2 = new FolderIndex(node1d, keys, "2d2");
Map<String, byte[]> same = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, same, same);
List<Index> addedRemotely = fileSynchronizer.getAddedRemotely();
Assert.assertEquals(2, addedRemotely.size());
Assert.assertTrue(addedRemotely.contains(node1f3));
Assert.assertTrue(addedRemotely.contains(node2d2));
}
@Test
public void testUpdatedLocally() throws IOException, ClassNotFoundException {
Map<String, byte[]> before = FileSynchronizer.visitFiles(rootFile);
// change two files
FileUtils.writeStringToFile(file1f2, randomString());
FileUtils.writeStringToFile(file2f, randomString());
Map<String, byte[]> after = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, before, after);
List<File> updatedLocally = fileSynchronizer.getUpdatedLocally();
Assert.assertEquals(2, updatedLocally.size());
Assert.assertTrue(updatedLocally.contains(file1f2));
Assert.assertTrue(updatedLocally.contains(file2f));
// change file in user profile as well --> should not occur as updated locally
node1f2.setHash(HashUtil.hash(randomString().getBytes()));
fileSynchronizer = new FileSynchronizer(rootFile, userProfile, before, after);
updatedLocally = fileSynchronizer.getUpdatedLocally();
Assert.assertEquals(1, updatedLocally.size());
Assert.assertTrue(updatedLocally.contains(file2f));
}
@Test
public void testUpdatedRemotely() throws IOException, ClassNotFoundException {
// change two files in the user profile; hashes on disk remain the same
node1f2.setHash(HashUtil.hash(randomString().getBytes()));
node2f.setHash(HashUtil.hash(randomString().getBytes()));
Map<String, byte[]> same = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, same, same);
List<FileIndex> updatedRemotely = fileSynchronizer.getUpdatedRemotely();
Assert.assertEquals(2, updatedRemotely.size());
Assert.assertTrue(updatedRemotely.contains(node1f2));
Assert.assertTrue(updatedRemotely.contains(node2f));
}
@Test
public void testNothingChanged() throws ClassNotFoundException, IOException {
// nothing has changed --> should receive no file to upload/download
Map<String, byte[]> same = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, same, same);
Assert.assertEquals(0, fileSynchronizer.getUpdatedRemotely().size());
Assert.assertEquals(0, fileSynchronizer.getUpdatedLocally().size());
Assert.assertEquals(0, fileSynchronizer.getAddedRemotely().size());
Assert.assertEquals(0, fileSynchronizer.getAddedLocally().size());
Assert.assertEquals(0, fileSynchronizer.getDeletedRemotely().size());
Assert.assertEquals(0, fileSynchronizer.getDeletedLocally().size());
}
@Test
public void testConflictUpdateLocallyDeleteRemotely() throws IOException, ClassNotFoundException {
Map<String, byte[]> before = FileSynchronizer.visitFiles(rootFile);
// change a file locally
FileUtils.writeStringToFile(file1f2, randomString());
// delete the same file remotely
root.removeChild(node1f2);
Map<String, byte[]> after = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, before, after);
List<File> addedLocally = fileSynchronizer.getAddedLocally();
Assert.assertEquals(1, addedLocally.size());
Assert.assertTrue(addedLocally.contains(file1f2));
List<File> deletedRemotely = fileSynchronizer.getDeletedRemotely();
Assert.assertTrue(deletedRemotely.isEmpty());
}
@Test
public void testConflictUpdateRemotelyDeleteLocally() throws IOException, ClassNotFoundException {
Map<String, byte[]> before = FileSynchronizer.visitFiles(rootFile);
// delete a file locally
file1f2.delete();
// modify the same file remotely
node1f2.setHash(HashUtil.hash(randomString().getBytes()));
Map<String, byte[]> after = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, before, after);
List<Index> addedRemotely = fileSynchronizer.getAddedRemotely();
Assert.assertEquals(1, addedRemotely.size());
Assert.assertTrue(addedRemotely.contains(node1f2));
List<FileIndex> updatedRemotely = fileSynchronizer.getUpdatedRemotely();
Assert.assertTrue(updatedRemotely.isEmpty());
List<Index> deletedLocally = fileSynchronizer.getDeletedLocally();
Assert.assertTrue(deletedLocally.isEmpty());
}
@Test
public void testConflictUpdateRemotelyAndLocally() throws IOException, ClassNotFoundException {
Map<String, byte[]> before = FileSynchronizer.visitFiles(rootFile);
// change a file in the user profile
node1f2.setHash(HashUtil.hash(randomString().getBytes()));
// change file on disk as well --> should occur as updated remotely since there is a conflict and the
// profile wins
FileUtils.writeStringToFile(file1f2, randomString());
Map<String, byte[]> after = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, before, after);
List<FileIndex> updatedRemotely = fileSynchronizer.getUpdatedRemotely();
Assert.assertEquals(1, updatedRemotely.size());
Assert.assertTrue(updatedRemotely.contains(node1f2));
List<File> updatedLocally = fileSynchronizer.getUpdatedLocally();
Assert.assertTrue(updatedLocally.isEmpty());
}
@Test
public void testConflictDeleteRemotelyAndLocally() throws IOException, ClassNotFoundException {
Map<String, byte[]> before = FileSynchronizer.visitFiles(rootFile);
// remove a file in the user profile and on disk
root.removeChild(node1f2);
file1f2.delete();
Map<String, byte[]> after = FileSynchronizer.visitFiles(rootFile);
FileSynchronizer fileSynchronizer = new FileSynchronizer(rootFile, userProfile, before, after);
List<Index> deletedRemotely = fileSynchronizer.getDeletedLocally();
Assert.assertTrue(deletedRemotely.isEmpty());
List<File> updatedLocally = fileSynchronizer.getDeletedRemotely();
Assert.assertTrue(updatedLocally.isEmpty());
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.extras;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.TrueFileFilter;
import org.hive2hive.core.file.FileUtil;
import org.hive2hive.core.model.FileIndex;
import org.hive2hive.core.model.FolderIndex;
import org.hive2hive.core.model.Index;
import org.hive2hive.core.model.versioned.UserProfile;
import org.hive2hive.core.security.HashUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Helps to synchronize when a client comes online. It compares the meta data from last logout with the
* current situation on disc and in the user profile.
*
* @author Nico
*
*/
@Extra
public class FileSynchronizer {
private static final Logger logger = LoggerFactory.getLogger(FileSynchronizer.class);
private final File root;
private final UserProfile userProfile;
private final FolderIndex profileRootNode;
// Map<file-path, file-hash>
private final Map<String, byte[]> before;
private final Map<String, byte[]> now;
/**
* @param rootDirectory the root Hive2Hive directory
* @param userProfile the current user profile
* @param before represents the file state at the last logout, before H2H was shutdown. The key of the map
* is the path, the byte[] is the hash of the file content.
* {@link FileSynchronizer#visitFiles(File)} can be used to generate this map.
* @param now represents the current file state. The key of the map is the path, the byte[] is the hash of
* the file content. {@link FileSynchronizer#visitFiles(File)} can be used to generate this
* map.
*/
public FileSynchronizer(File rootDirectory, UserProfile userProfile, Map<String, byte[]> before, Map<String, byte[]> now) {
this.root = rootDirectory;
this.userProfile = userProfile;
this.before = before;
this.now = now;
this.profileRootNode = userProfile.getRoot();
}
/**
* Returns a list of files that have been deleted from the disc during this client was offline
*
* @return a list of files that has been deleted locally
*/
public List<Index> getDeletedLocally() {
List<Index> deletedLocally = new ArrayList<Index>();
for (String path : before.keySet()) {
if (now.containsKey(path)) {
// skip, this file is still here
continue;
} else {
// test whether it is in the user profile
Index node = userProfile.getFileByPath(new File(root, path), root);
if (node != null) {
// file is still in user profile
if (node.isFolder()) {
deletedLocally.add(node);
} else {
// check the hash value to not delete a modified file
FileIndex fileNode = (FileIndex) node;
if (HashUtil.compare(fileNode.getHash(), before.get(path))) {
// file has not been modified remotely, delete it
logger.debug("File '{}' has been deleted locally during absence.", path);
deletedLocally.add(node);
}
}
}
}
}
// delete from behind
sortNodesPreorder(deletedLocally);
Collections.reverseOrder();
logger.info("Found {} files/folders that have been deleted locally during absence.", deletedLocally.size());
return deletedLocally;
}
/**
* Returns a list of files that have been deleted by another client during the absence of this client.
*
* @return a list of files that has been deleted remotely
*/
public List<File> getDeletedRemotely() {
List<File> deletedRemotely = new ArrayList<File>();
for (String p : now.keySet()) {
File file = new File(root, p);
if (before.containsKey(p) && userProfile.getFileByPath(file, root) == null) {
// is on disk but deleted in the user profile
if (HashUtil.compare(before.get(p), now.get(p))) {
// only delete the file, if it was not modified locally
deletedRemotely.add(file);
}
}
}
logger.debug("Found {} files/folders that have been deleted remotely during absence.", deletedRemotely.size());
return deletedRemotely;
}
/**
* Returns the missing files that exist on disk but not in the file tree in the user profile. The list is
* in pre-order
*
* @return a list of files that has been added locally
*/
public List<File> getAddedLocally() {
List<File> addedLocally = new ArrayList<File>();
for (String p : now.keySet()) {
File file = new File(root, p);
// test whether it is in the user profile
Index node = userProfile.getFileByPath(file, root);
if (node == null) {
// not in profile --> it has been added locally
logger.debug("File '{}' has been added locally during absence.", p);
addedLocally.add(file);
}
}
sortFilesPreorder(addedLocally);
logger.info("Found {} files/folders that have been added locally during absence.", addedLocally.size());
return addedLocally;
}
/**
* Returns a list of files that are in the user profile but not on the local disk yet.
*
* @return a list of files that has been added remotely
*/
public List<Index> getAddedRemotely() {
List<Index> addedRemotely = new ArrayList<Index>();
// visit all files in the tree and compare to disk
List<Index> indexList = Index.getIndexList(profileRootNode);
indexList.remove(profileRootNode);
for (Index index : indexList) {
if (now.containsKey(index.getFullPath())) {
// was here before and is still here --> nothing to add
logger.trace("File '{}' was already here.", index.getFullPath());
} else {
logger.debug("File '{}' has been added remotely during absence.", index.getFullPath());
addedRemotely.add(index);
}
}
sortNodesPreorder(addedRemotely);
logger.info("Found {} files/folders that have been added remotely during absence.", addedRemotely.size());
return addedRemotely;
}
/**
* Returns a list of files that already existed but have been modified by the client while he was offline.
*
* @return a list of files that has been updated locally
*/
public List<File> getUpdatedLocally() {
List<File> updatedLocally = new ArrayList<File>();
for (String path : now.keySet()) {
if (!before.containsKey(path)) {
// was not here before --> skip
continue;
}
if (HashUtil.compare(before.get(path), now.get(path))) {
// hash before and after match --> nothing changed
continue;
}
File file = new File(root, path);
Index index = userProfile.getFileByPath(file, root);
if (index == null || index.isFolder()) {
// file not found --> skip, this is not the task of this method
// file node is a folder --> cannot compare the modification
continue;
}
FileIndex fileNode = (FileIndex) index;
// has been modified --> check if profile has same hash as 'before'. If not, there are three
// different versions. Thus, the profile wins.
if (HashUtil.compare(fileNode.getHash(), before.get(path)) && !HashUtil.compare(fileNode.getHash(), now.get(path))) {
logger.debug("File '{}' has been updated locally during absence.", path);
updatedLocally.add(file);
}
}
sortFilesPreorder(updatedLocally);
logger.info("Found {} files/folders that have been updated locally during absence.", updatedLocally.size());
return updatedLocally;
}
/**
* Returns files that have been remotely modified while the client was offline
*
* @return a list of files that has been updated remotely
*/
public List<FileIndex> getUpdatedRemotely() {
List<FileIndex> updatedRemotely = new ArrayList<FileIndex>();
// visit all files in the tree and compare to disk
List<Index> indexList = Index.getIndexList(profileRootNode);
for (Index index : indexList) {
if (index.isFolder()) {
// folder cannot be modified
continue;
}
FileIndex fileIndex = (FileIndex) index;
String path = fileIndex.getFullPath();
if (before.containsKey(path) && now.containsKey(path)) {
if (!HashUtil.compare(fileIndex.getHash(), now.get(path))
&& !HashUtil.compare(fileIndex.getHash(), before.get(path))) {
// different hashes than 'before' and 'now'
logger.debug("File '{}' has been updated remotely during absence.", path);
updatedRemotely.add(fileIndex);
}
}
}
logger.info("Found {} files/folders that have been updated remotely during absence.", updatedRemotely.size());
return updatedRemotely;
}
/**
* Sorts a list of {@link FolderIndex} in pre-order style
*
* @param deletedLocally
*/
private void sortNodesPreorder(List<Index> fileList) {
Collections.sort(fileList, new Comparator<Index>() {
@Override
public int compare(Index node1, Index node2) {
return node1.getFullPath().compareTo(node2.getFullPath());
}
});
}
/**
* Sorts a list of files in pre-order style
*
* @param deletedLocally
*/
private void sortFilesPreorder(List<File> fileList) {
Collections.sort(fileList, new Comparator<File>() {
@Override
public int compare(File file1, File file2) {
return file1.compareTo(file2);
}
});
}
/**
* Visit all files recursively and calculate the hash of the file. Folders are also added to the result.
*
* @param root the root folder
* @return a map where the key is the relative file path to the root and the value is the hash
* @throws IOException if hashing fails
*/
public static Map<String, byte[]> visitFiles(File root) throws IOException {
Map<String, byte[]> digest = new HashMap<String, byte[]>();
Iterator<File> files = FileUtils.iterateFilesAndDirs(root, TrueFileFilter.TRUE, TrueFileFilter.TRUE);
while (files.hasNext()) {
File file = files.next();
if (file.equals(root)) {
// skip root folder
continue;
}
String path = FileUtil.relativize(root, file).toString();
byte[] hash = HashUtil.hash(file);
if (file.isDirectory()) {
digest.put(path + FileUtil.getFileSep(), hash);
} else {
digest.put(path, hash);
}
}
return digest;
}
}
```
|
```package org.hive2hive.core.integration;
import java.io.File;
import java.io.IOException;
import java.util.List;
import org.apache.commons.io.FileUtils;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.api.H2HNode;
import org.hive2hive.core.api.configs.FileConfiguration;
import org.hive2hive.core.api.interfaces.IFileConfiguration;
import org.hive2hive.core.api.interfaces.IH2HNode;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.exceptions.NoSessionException;
import org.hive2hive.core.security.UserCredentials;
import org.hive2hive.core.utils.NetworkTestUtil;
import org.hive2hive.core.utils.TestExecutionUtil;
import org.hive2hive.core.utils.helper.TestFileAgent;
import org.hive2hive.processframework.interfaces.IProcessComponent;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* Integration tests for the H2HNode.
*
* @author Nico
*
*/
public class H2HNodeTest extends H2HJUnitTest {
private static List<IH2HNode> network;
private static IH2HNode loggedInNode;
private static UserCredentials credentials;
private static TestFileAgent fileAgent;
@BeforeClass
public static void initTest() throws Exception {
testClass = H2HNodeTest.class;
beforeClass();
network = NetworkTestUtil.createH2HNetwork(5);
credentials = generateRandomCredentials();
IH2HNode registerNode = network.get(0);
IProcessComponent<?> registerProcess = registerNode.getUserManager().createRegisterProcess(credentials);
TestExecutionUtil.executeProcessTillSucceded(registerProcess);
fileAgent = new TestFileAgent();
loggedInNode = network.get(1);
IProcessComponent<Void> loginProcess = loggedInNode.getUserManager().createLoginProcess(credentials, fileAgent);
TestExecutionUtil.executeProcessTillSucceded(loginProcess);
}
@AfterClass
public static void cleanAfterClass() {
NetworkTestUtil.shutdownH2HNetwork(network);
afterClass();
}
@Test
public void testAddDeleteFile() throws IOException, NoSessionException, NoSuchFieldException, SecurityException,
IllegalArgumentException, IllegalAccessException, NoPeerConnectionException {
File testFile = new File(fileAgent.getRoot(), "test-file1");
FileUtils.write(testFile, "Hello World 1");
IProcessComponent<Void> process = loggedInNode.getFileManager().createAddProcess(testFile);
TestExecutionUtil.executeProcessTillSucceded(process);
// is now added; delete it
process = loggedInNode.getFileManager().createDeleteProcess(testFile);
TestExecutionUtil.executeProcessTillSucceded(process);
}
@Test(expected = IllegalArgumentException.class)
public void testAddFileWrongDir() throws IOException, NoPeerConnectionException, NoSessionException,
IllegalArgumentException {
File testFile = new File(tempFolder.newFolder(), "test-file2");
FileUtils.write(testFile, "Hello World 2");
loggedInNode.getFileManager().createAddProcess(testFile);
}
@Test
public void getPeer() {
// a unconnected node does not provide a peer
IFileConfiguration fileConfig = FileConfiguration.createDefault();
IH2HNode node = H2HNode.createNode(fileConfig);
Assert.assertNull(node.getPeer());
// connected nodes return a peer
for (IH2HNode connectedNode : network) {
Assert.assertNotNull(connectedNode.getPeer());
}
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.api;
import net.tomp2p.dht.PeerDHT;
import org.hive2hive.core.api.interfaces.IFileConfiguration;
import org.hive2hive.core.api.interfaces.IFileManager;
import org.hive2hive.core.api.interfaces.IH2HNode;
import org.hive2hive.core.api.interfaces.INetworkConfiguration;
import org.hive2hive.core.api.interfaces.IUserManager;
import org.hive2hive.core.network.NetworkManager;
import org.hive2hive.core.security.H2HDefaultEncryption;
import org.hive2hive.core.security.IH2HEncryption;
import org.hive2hive.core.serializer.FSTSerializer;
import org.hive2hive.core.serializer.IH2HSerialize;
/**
* Default implementation of {@link IH2HNode}.
*
* @author Christian, Nico
*
*/
public class H2HNode implements IH2HNode {
private final IFileConfiguration fileConfiguration;
private final NetworkManager networkManager;
private IUserManager userManager;
private IFileManager fileManager;
private H2HNode(IFileConfiguration fileConfiguration, IH2HEncryption encryption, IH2HSerialize serializer) {
this.fileConfiguration = fileConfiguration;
this.networkManager = new NetworkManager(encryption, serializer, fileConfiguration);
}
/**
* Create a Hive2Hive node instance. Before the node can be used, a
* {@link IH2HNode#connect(INetworkConfiguration)} must be
* called.
*
* @param fileConfiguration the file configuration
* @return the Hive2Hive node
*/
public static IH2HNode createNode(IFileConfiguration fileConfiguration) {
FSTSerializer serializer = new FSTSerializer();
return new H2HNode(fileConfiguration, new H2HDefaultEncryption(serializer), serializer);
}
/**
* Same as {@link H2HNode#createNode(IFileConfiguration)}, but with additional
* capability to provide an own encryption and serialization implementation
*
* @param fileConfiguration the file configuration
* @param encryption and decryption implementation
* @param serializer the serialization implementation
* @return the Hive2Hive node
*/
public static IH2HNode createNode(IFileConfiguration fileConfiguration, IH2HEncryption encryption,
IH2HSerialize serializer) {
return new H2HNode(fileConfiguration, encryption, serializer);
}
@Override
public boolean connect(INetworkConfiguration networkConfiguration) {
return networkManager.connect(networkConfiguration);
}
@Override
public boolean connect(PeerDHT peer, boolean startReplication) {
return networkManager.connect(peer, startReplication);
}
@Override
public boolean disconnect() {
return networkManager.disconnect(false);
}
@Override
public boolean disconnectKeepSession() {
return networkManager.disconnect(true);
}
@Override
public boolean isConnected() {
return networkManager.isConnected();
}
@Override
public IUserManager getUserManager() {
if (userManager == null) {
userManager = new H2HUserManager(networkManager);
}
return userManager;
}
@Override
public IFileManager getFileManager() {
if (fileManager == null) {
fileManager = new H2HFileManager(networkManager, fileConfiguration);
}
return fileManager;
}
@Override
public IFileConfiguration getFileConfiguration() {
return fileConfiguration;
}
@Override
public PeerDHT getPeer() {
return networkManager.getConnection().getPeer();
}
}
```
|
```package org.hive2hive.core.utils.helper;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.file.IFileAgent;
public class TestFileAgent implements IFileAgent {
private final File root;
public TestFileAgent() throws IOException {
root = H2HJUnitTest.tempFolder.newFolder();
}
public TestFileAgent(File root) {
this.root = root;
}
@Override
public void writeCache(String name, byte[] data) throws IOException {
FileUtils.writeByteArrayToFile(new File(root, name), data);
}
@Override
public byte[] readCache(String name) throws IOException {
return FileUtils.readFileToByteArray(new File(root, name));
}
@Override
public File getRoot() {
return root;
}
@Override
protected void finalize() throws Throwable {
// cleanup when object is not used anymore
FileUtils.deleteDirectory(root);
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.file;
import java.io.File;
import java.io.IOException;
/**
* Since Hive2Hive does not any file operations itself, the implementation of this interface needs to be
* provided by the user. The implementation may differ from Windows to Mac or other platforms.
* A {@link IFileAgent} must be handed at every login and can differ between multiple users.
*
* @author Nico
*
*/
public interface IFileAgent {
/**
* @return the root directory of Hive2Hive for that user
*/
File getRoot();
/**
* Write to a persistent cache which is available after a restart.
*
* @param key the filename or other unique key to write. If a key is re-used, the data should be
* <strong>overwritten</strong>, not appended.
* @param data the data to write
* @throws IOException if writing fails
*/
void writeCache(String key, byte[] data) throws IOException;
/**
* Reads from the cache at the given name (or key)
*
* @param key the filename or other unique key to read from. Return either an empty byte-array or null if
* the data is not available.
* @return the data associated with the name <code>null</code> or an empty array.
* @throws IOException if reading fails
*/
byte[] readCache(String key) throws IOException;
}
```
|
```package org.hive2hive.core.model.versioned;
import java.io.File;
import java.io.IOException;
import java.security.KeyPair;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.model.FileIndex;
import org.hive2hive.core.model.FolderIndex;
import org.hive2hive.core.security.EncryptionUtil.RSA_KEYLENGTH;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
public class UserProfileTest extends H2HJUnitTest {
private UserProfile userProfile;
@BeforeClass
public static void initTest() throws Exception {
testClass = UserProfileTest.class;
beforeClass();
}
@AfterClass
public static void cleanAfterClass() {
afterClass();
}
@Before
public void createUserProfile() {
userProfile = new UserProfile(randomString(), generateRSAKeyPair(H2HConstants.KEYLENGTH_USER_KEYS),
generateRSAKeyPair(H2HConstants.KEYLENGTH_PROTECTION));
}
@Test
public void testGetFileById() {
FolderIndex root = userProfile.getRoot();
KeyPair child1Key = generateRSAKeyPair(RSA_KEYLENGTH.BIT_512);
FolderIndex child1Folder = new FolderIndex(root, child1Key, randomString());
KeyPair child2Key = generateRSAKeyPair(RSA_KEYLENGTH.BIT_1024);
new FileIndex(root, child2Key, randomString(), "bla".getBytes());
KeyPair child3Key = generateRSAKeyPair(RSA_KEYLENGTH.BIT_2048);
new FileIndex(child1Folder, child3Key, randomString(), "blubb".getBytes());
Assert.assertNotNull(userProfile.getFileById(child1Key.getPublic()));
Assert.assertNotNull(userProfile.getFileById(child2Key.getPublic()));
Assert.assertNotNull(userProfile.getFileById(child3Key.getPublic()));
}
@Test
public void getFileByPath() throws IOException {
FolderIndex root = userProfile.getRoot();
// tree in the UP
FolderIndex folderIndex1 = new FolderIndex(root, generateRSAKeyPair(RSA_KEYLENGTH.BIT_512), randomString());
FileIndex fileIndex1 = new FileIndex(folderIndex1, generateRSAKeyPair(RSA_KEYLENGTH.BIT_512), randomString(),
"bla".getBytes());
FileIndex fileIndex2 = new FileIndex(folderIndex1, generateRSAKeyPair(RSA_KEYLENGTH.BIT_512), randomString(),
"blubb".getBytes());
FolderIndex folderIndex2 = new FolderIndex(folderIndex1, generateRSAKeyPair(RSA_KEYLENGTH.BIT_512), randomString());
FileIndex fileIndex3 = new FileIndex(folderIndex2, generateRSAKeyPair(RSA_KEYLENGTH.BIT_512), randomString(),
"bla".getBytes());
// tree on the FS
File rootFile = tempFolder.newFolder();
File folder1 = new File(rootFile, folderIndex1.getName());
File file1 = new File(folder1, fileIndex1.getName());
File file2 = new File(folder1, fileIndex2.getName());
File folder2 = new File(folder1, folderIndex2.getName());
File file3 = new File(folder2, fileIndex3.getName());
Assert.assertEquals(root, userProfile.getFileByPath(rootFile, rootFile));
Assert.assertEquals(folderIndex1, userProfile.getFileByPath(folder1, rootFile));
Assert.assertEquals(fileIndex1, userProfile.getFileByPath(file1, rootFile));
Assert.assertEquals(fileIndex2, userProfile.getFileByPath(file2, rootFile));
Assert.assertEquals(folderIndex2, userProfile.getFileByPath(folder2, rootFile));
Assert.assertEquals(fileIndex3, userProfile.getFileByPath(file3, rootFile));
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.model.versioned;
import java.io.File;
import java.security.KeyPair;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.hive2hive.core.TimeToLiveStore;
import org.hive2hive.core.model.FolderIndex;
import org.hive2hive.core.model.Index;
import org.hive2hive.core.model.PermissionType;
import org.hive2hive.core.model.UserPermission;
/**
* File which contains all keys and meta information about the files of the owner.
*
* @author Nico, Seppi
*
*/
public class UserProfile extends BaseVersionedNetworkContent {
private static final long serialVersionUID = -8089242126512434561L;
private final String userId;
private final KeyPair encryptionKeys;
private final FolderIndex root;
public UserProfile(String userId, KeyPair encryptionKeys, KeyPair protectionKeys) {
assert userId != null;
this.userId = userId;
this.encryptionKeys = encryptionKeys;
// create the root node
root = new FolderIndex(encryptionKeys);
root.setProtectionKeys(protectionKeys);
root.addUserPermissions(new UserPermission(userId, PermissionType.WRITE));
}
public String getUserId() {
return userId;
}
public KeyPair getEncryptionKeys() {
return encryptionKeys;
}
public KeyPair getProtectionKeys() {
return root.getProtectionKeys();
}
public FolderIndex getRoot() {
return root;
}
@Override
public int getTimeToLive() {
return TimeToLiveStore.getInstance().getUserProfile();
}
@Override
protected int getContentHash() {
return userId.hashCode() + 21 * encryptionKeys.hashCode();
}
public Index getFileById(PublicKey fileId) {
return findById(root, fileId);
}
private Index findById(Index current, PublicKey fileId) {
if (current.getFilePublicKey().equals(fileId)) {
return current;
}
Index found = null;
if (current instanceof FolderIndex) {
FolderIndex folder = (FolderIndex) current;
for (Index child : folder.getChildren()) {
found = findById(child, fileId);
if (found != null) {
return found;
}
}
}
return found;
}
public Index getFileByPath(File file, File root) {
// holds all files in-order
File currentFile = new File(file.getAbsolutePath());
List<String> filePath = new ArrayList<String>();
while (!root.equals(currentFile) && currentFile != null) {
filePath.add(currentFile.getName());
currentFile = currentFile.getParentFile();
}
Collections.reverse(filePath);
FolderIndex currentIndex = this.root;
for (String fileName : filePath) {
Index child = currentIndex.getChildByName(fileName);
if (child == null) {
return null;
} else if (child instanceof FolderIndex) {
currentIndex = (FolderIndex) child;
} else if (child.getName().equals(file.getName())) {
return child;
}
}
return currentIndex;
}
}
```
|
```package org.hive2hive.core.processes.register;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import java.util.List;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.exceptions.GetFailedException;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.model.UserPublicKey;
import org.hive2hive.core.model.versioned.Locations;
import org.hive2hive.core.model.versioned.UserProfile;
import org.hive2hive.core.network.NetworkManager;
import org.hive2hive.core.network.data.DataManager.H2HPutStatus;
import org.hive2hive.core.network.data.parameters.Parameters;
import org.hive2hive.core.processes.ProcessFactory;
import org.hive2hive.core.security.UserCredentials;
import org.hive2hive.core.utils.NetworkTestUtil;
import org.hive2hive.core.utils.TestExecutionUtil;
import org.hive2hive.core.utils.UseCaseTestUtil;
import org.hive2hive.processframework.exceptions.InvalidProcessStateException;
import org.hive2hive.processframework.interfaces.IProcessComponent;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public class RegisterProcessTest extends H2HJUnitTest {
private static List<NetworkManager> network;
@BeforeClass
public static void initTest() throws Exception {
testClass = RegisterProcessTest.class;
beforeClass();
network = NetworkTestUtil.createNetwork(DEFAULT_NETWORK_SIZE);
}
@AfterClass
public static void endTest() {
NetworkTestUtil.shutdownNetwork(network);
afterClass();
}
@Test
public void testRegisterProcessSuccess() throws InvalidProcessStateException, ClassNotFoundException, IOException,
GetFailedException, NoPeerConnectionException {
NetworkManager client = network.get(0);
NetworkManager otherClient = network.get(1);
UserCredentials credentials = generateRandomCredentials();
UseCaseTestUtil.register(credentials, client);
// verify put user profile
UserProfile getUserProfile = UseCaseTestUtil.getUserProfile(otherClient, credentials);
assertNotNull(getUserProfile);
assertEquals(credentials.getUserId(), getUserProfile.getUserId());
// verify put locations
Locations locations = (Locations) otherClient.getDataManager().get(
new Parameters().setLocationKey(credentials.getUserId()).setContentKey(H2HConstants.USER_LOCATIONS));
assertNotNull(locations);
assertEquals(credentials.getUserId(), locations.getUserId());
assertTrue(locations.getPeerAddresses().isEmpty());
// verify put user public key
UserPublicKey publicKey = (UserPublicKey) otherClient.getDataManager().get(
new Parameters().setLocationKey(credentials.getUserId()).setContentKey(H2HConstants.USER_PUBLIC_KEY));
assertNotNull(publicKey);
}
@Test
public void testFailOnExistingLocations() throws InvalidProcessStateException, NoPeerConnectionException {
NetworkManager client = network.get(0);
UserCredentials credentials = generateRandomCredentials();
// already put a locations map
assertEquals(
H2HPutStatus.OK,
client.getDataManager().put(
new Parameters().setLocationKey(credentials.getUserId()).setContentKey(H2HConstants.USER_LOCATIONS)
.setNetworkContent(new Locations(credentials.getUserId()))));
IProcessComponent<Void> registerProcess = ProcessFactory.instance().createRegisterProcess(credentials, client);
TestExecutionUtil.executeProcessTillFailed(registerProcess);
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.processes.context;
import java.security.KeyPair;
import javax.crypto.SecretKey;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.model.versioned.UserProfile;
import org.hive2hive.core.security.PasswordUtil;
import org.hive2hive.core.security.UserCredentials;
/**
* @author Nico, Seppi
*/
public final class RegisterProcessContext {
private final UserCredentials userCredentials;
private UserProfile profile;
public RegisterProcessContext(UserCredentials userCredentials) {
this.userCredentials = userCredentials;
}
public String consumeUserId() {
return userCredentials.getUserId();
}
public String consumeUserProflieLocationKey() {
return userCredentials.getProfileLocationKey();
}
public void provideUserProfile(UserProfile profile) {
this.profile = profile;
}
public UserProfile consumeUserProfile() {
return profile;
}
public KeyPair consumeUserLocationsProtectionKeys() {
return profile.getProtectionKeys();
}
public KeyPair consumeUserProfileProtectionKeys() {
return profile.getProtectionKeys();
}
public KeyPair consumeUserPublicKeyProtectionKeys() {
return profile.getProtectionKeys();
}
public SecretKey consumeUserProfileEncryptionKeys() {
return PasswordUtil.generateAESKeyFromPassword(userCredentials.getPassword(), userCredentials.getPin(),
H2HConstants.KEYLENGTH_USER_PROFILE);
}
}
```
|
```package org.hive2hive.core.utils.helper;
import io.netty.buffer.Unpooled;
import java.io.IOException;
import net.tomp2p.message.Buffer;
import net.tomp2p.peers.PeerAddress;
import net.tomp2p.rpc.RawDataReply;
import org.hive2hive.core.network.messages.AcceptanceReply;
import org.hive2hive.core.serializer.FSTSerializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Denies all messages; can be useful for some tests
*
* @author Nico, Seppi
*/
public class DenyingMessageReplyHandler implements RawDataReply {
private static final Logger logger = LoggerFactory.getLogger(DenyingMessageReplyHandler.class);
private final byte[] serializedReply;
public DenyingMessageReplyHandler() throws IOException {
serializedReply = new FSTSerializer().serialize(AcceptanceReply.FAILURE);
}
@Override
public Buffer reply(PeerAddress sender, Buffer requestBuffer, boolean complete) throws Exception {
logger.warn("Denying a message. Sender = '{}'.", sender);
return new Buffer(Unpooled.wrappedBuffer(serializedReply));
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.network.messages;
import io.netty.buffer.Unpooled;
import net.tomp2p.message.Buffer;
import net.tomp2p.peers.PeerAddress;
import net.tomp2p.rpc.ObjectDataReply;
import net.tomp2p.rpc.RawDataReply;
import org.hive2hive.core.H2HSession;
import org.hive2hive.core.exceptions.GetFailedException;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.exceptions.NoSessionException;
import org.hive2hive.core.model.versioned.HybridEncryptedContent;
import org.hive2hive.core.network.NetworkManager;
import org.hive2hive.core.security.EncryptionUtil;
import org.hive2hive.core.serializer.IH2HSerialize;
import org.hive2hive.core.serializer.SerializerUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.Serializable;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.PublicKey;
import java.security.SignatureException;
/**
* This is the general message handler of each node. It checks if received
* message is ok (depends on message e.g. routed to correct node). If accepted
* the message gets independently handled in a own thread. As soon as the
* handler thread has started the reply handler gives immediately response to
* the sender node. This design allows a quick and non-blocking message
* handling.
*
* @author Nendor
* @author Seppi
* @author Nico
*/
public class MessageReplyHandler implements RawDataReply, ObjectDataReply
{
private static final Logger logger = LoggerFactory.getLogger(MessageReplyHandler.class);
private final NetworkManager networkManager;
private final IH2HSerialize serializer;
public MessageReplyHandler(NetworkManager networkManager, IH2HSerialize serializer)
{
this.networkManager = networkManager;
this.serializer = serializer;
}
@Override
public Buffer reply(PeerAddress sender, Buffer requestBuffer, boolean complete) throws Exception
{
byte[] rawRequest = SerializerUtil.convertToByteArray(requestBuffer.buffer());
Object request;
try
{
request = serializer.deserialize(rawRequest);
}
catch(IOException | ClassNotFoundException e)
{
logger.error("Cannot deserialize the raw request from sender {}", sender);
return new Buffer(Unpooled.wrappedBuffer(
serializer.serialize(AcceptanceReply.FAILURE_DESERIALIZATION)));
}
Object reply = reply(sender, request);
byte[] rawReply;
if (reply instanceof Serializable)
{
rawReply = serializer.serialize((Serializable) reply);
}
else if (reply == null)
{
logger.error("The reply is null.");
return null;
}
else
{
logger.error("Cannot serialize the response. It is of kind {}", reply.getClass().getName());
rawReply = serializer.serialize(AcceptanceReply.FAILURE);
}
return new Buffer(Unpooled.wrappedBuffer(rawReply));
}
@Override
public Object reply(PeerAddress sender, Object request)
{
if (!(request instanceof HybridEncryptedContent))
{
logger.error("Received unknown object {}", request);
return null;
}
H2HSession session;
try
{
if (networkManager.getSession() == null)
{
throw new NoSessionException();
}
else
{
session = networkManager.getSession();
}
}
catch(NoSessionException e)
{
logger.warn("Currently no user is logged in! Keys for decryption needed. Node ID = '{}'.",
networkManager.getNodeId());
return AcceptanceReply.FAILURE;
}
HybridEncryptedContent encryptedMessage = (HybridEncryptedContent) request;
// get signature
String senderId = encryptedMessage.getUserId();
byte[] signature = encryptedMessage.getSignature();
if (senderId == null || signature == null)
{
logger.warn("No signature for message.");
return AcceptanceReply.FAILURE_SIGNATURE;
}
// asymmetrically decrypt message
byte[] decryptedMessage = null;
try
{
KeyPair keys = session.getKeyPair();
decryptedMessage = networkManager.getEncryption()
.decryptHybridRaw(encryptedMessage, keys.getPrivate());
}
catch(Exception e)
{
logger.warn("Decryption of message failed.", e);
return AcceptanceReply.FAILURE_DECRYPTION;
}
// deserialize decrypted message
Object message = null;
try
{
message = serializer.deserialize(decryptedMessage);
}
catch(IOException | ClassNotFoundException e)
{
logger.error("Message could not be deserialized.", e);
return AcceptanceReply.FAILURE_DESERIALIZATION;
}
if (message != null && message instanceof BaseMessage)
{
BaseMessage receivedMessage = (BaseMessage) message;
// verify the signature
if (session.getKeyManager().containsPublicKey(senderId))
{
if (!verifySignature(senderId, decryptedMessage, signature))
{
return AcceptanceReply.FAILURE_SIGNATURE;
}
// give a network manager reference to work (verify, handle)
try
{
receivedMessage.setNetworkManager(networkManager);
}
catch(NoPeerConnectionException e)
{
logger.error("Cannot process the message because the peer is not connected.", e);
return AcceptanceReply.FAILURE;
}
// check if message gets accepted
AcceptanceReply reply = receivedMessage.accept();
if (AcceptanceReply.OK == reply)
{
// handle message in own thread
logger.debug("Received and accepted the message. Node ID = '{}'.",
networkManager.getNodeId());
new Thread(receivedMessage).start();
}
else
{
logger.warn(
"Received but denied a message. Acceptance reply = '{}', Node ID = '{}'.",
reply, networkManager.getNodeId());
}
return reply;
}
else
{
new Thread(new VerifyMessage(senderId, decryptedMessage, signature, receivedMessage))
.start();
return AcceptanceReply.OK_PROVISIONAL;
}
}
else
{
logger.error("Received unknown object.");
return null;
}
}
private boolean verifySignature(String senderId, byte[] decryptedMessage, byte[] signature)
{
try
{
PublicKey publicKey = networkManager.getSession().getKeyManager().getPublicKey(senderId);
if (EncryptionUtil.verify(decryptedMessage, signature, publicKey,
networkManager.getEncryption().getSecurityProvider()))
{
logger.debug("Message signature from user '{}' verified. Node ID = '{}'.", senderId,
networkManager.getNodeId());
return true;
}
else
{
logger.error("Message from user '{}' has wrong signature. Node ID = '{}'.", senderId,
networkManager.getNodeId());
return false;
}
}
catch(GetFailedException | InvalidKeyException | SignatureException | NoSessionException e)
{
logger.error("Verifying message from user '{}' failed.", senderId, e);
return false;
}
}
private class VerifyMessage implements Runnable
{
private final String senderId;
private final byte[] decryptedMessage;
private final byte[] signature;
private final BaseMessage message;
public VerifyMessage(String senderId,
byte[] decryptedMessage,
byte[] signature,
BaseMessage message)
{
this.senderId = senderId;
this.decryptedMessage = decryptedMessage;
this.signature = signature;
this.message = message;
}
@Override
public void run()
{
if (!verifySignature(senderId, decryptedMessage, signature))
{
return;
}
// give a network manager reference to work (verify, handle)
try
{
message.setNetworkManager(networkManager);
}
catch(NoPeerConnectionException e)
{
logger.error("Cannot process the message because the peer is not connected.", e);
return;
}
// check if message gets accepted
AcceptanceReply reply = message.accept();
if (AcceptanceReply.OK == reply)
{
// handle message in own thread
logger.debug("Received and accepted the message. Node ID = '{}'.",
networkManager.getNodeId());
new Thread(message).start();
}
else
{
logger.warn("Received but denied a message. Acceptance reply = '{}', Node ID = '{}'.",
reply, networkManager.getNodeId());
}
}
}
}
```
|
```package org.hive2hive.core.model;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.security.UserCredentials;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* Tests the user credentials behavior
*
* @author Nico
*
*/
public class UserCredentialsTest extends H2HJUnitTest {
@BeforeClass
public static void initTest() throws Exception {
testClass = UserCredentialsTest.class;
beforeClass();
}
@Test
public void generateLocations() {
// random credentials
String userName = randomString();
String password = randomString();
String pin = randomString();
UserCredentials credentials1 = new UserCredentials(userName, password, pin);
UserCredentials credentials2 = new UserCredentials(userName, password, pin);
// test if same result twice
Assert.assertEquals(credentials1.getProfileLocationKey(), credentials2.getProfileLocationKey());
// test whether the method does not return false positives
UserCredentials wrongCredentials1 = new UserCredentials(userName + "A", password, pin);
UserCredentials wrongCredentials2 = new UserCredentials(userName, password + "-B", pin);
UserCredentials wrongCredentials3 = new UserCredentials(userName, password, pin + "_C");
Assert.assertNotEquals(credentials1.getProfileLocationKey(), wrongCredentials1.getProfileLocationKey());
Assert.assertNotEquals(credentials1.getProfileLocationKey(), wrongCredentials2.getProfileLocationKey());
Assert.assertNotEquals(credentials1.getProfileLocationKey(), wrongCredentials3.getProfileLocationKey());
}
@AfterClass
public static void cleanAfterClass() {
afterClass();
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.security;
/**
* This stores a user's credentials. Do not change the password or the PIN manually by using
* setters but rather define both parameters from scratch. The PIN needs to be unique per-user per-password.
*
* @author Christian
*
*/
public final class UserCredentials {
private final String userId;
private final String password;
private final String pin;
private final String locationCache;
public UserCredentials(String userId, String password, String pin) {
this.userId = userId;
this.password = password;
this.pin = pin;
this.locationCache = calculateLocationCache();
}
public String getUserId() {
return userId;
}
public String getPassword() {
return password;
}
public String getPin() {
return pin;
}
public String getProfileLocationKey() {
return locationCache;
}
/**
* Calculates the location for this {@link UserCredentials}. Once calculated, the location gets cached and
* directly returned on further invokes.
*
* @return The location key associated with this credentials.
*/
private String calculateLocationCache() {
// concatenate PIN + PW + UserId
String appendage = new StringBuilder().append(pin).append(password).append(userId).toString();
// create fixed salt based on location
byte[] fixedSalt = PasswordUtil.generateFixedSalt(appendage.getBytes());
// hash the location
byte[] locationKey = PasswordUtil.generateHash(appendage.toCharArray(), fixedSalt);
// Note: Do this as hex to support all platforms
return EncryptionUtil.byteToHex(locationKey);
}
}
```
|
```package org.hive2hive.core.events;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import java.util.List;
import org.apache.commons.io.FileUtils;
import org.hive2hive.core.events.framework.interfaces.file.IFileEvent;
import org.hive2hive.core.events.framework.interfaces.file.IFileUpdateEvent;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.exceptions.NoSessionException;
import org.hive2hive.core.utils.UseCaseTestUtil;
import org.junit.Test;
public class FileUpdateEventsTest extends FileEventsTest {
static {
testClass = FileUpdateEventsTest.class;
}
@Test
public void testFileUpdateEvent() throws NoPeerConnectionException, IOException, NoSessionException {
// upload a file from machine A
File file = createAndAddFile(rootA, clientA);
// clear past events of upload
waitForNumberOfEvents(1);
listener.getEvents().clear();
// update the file
FileUtils.write(file, randomString());
UseCaseTestUtil.uploadNewVersion(clientA, file);
// wait for event
waitForNumberOfEvents(1);
// check event type
List<IFileEvent> events = listener.getEvents();
assertEventType(events, IFileUpdateEvent.class);
// check paths
assertTrue(events.size() == 1);
IFileEvent ev = events.get(0);
assertTrue(ev.isFile());
assertFalse(ev.isFolder());
assertEqualsRelativePaths(file, ev.getFile());
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.events.framework.interfaces.file;
public interface IFileUpdateEvent extends IFileEvent {
}
```
|
```package org.hive2hive.core.network.data.vdht;
import java.util.List;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.model.versioned.Locations;
import org.hive2hive.core.network.NetworkManager;
import org.hive2hive.core.utils.NetworkTestUtil;
import org.hive2hive.core.utils.UseCaseTestUtil;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* @author Seppi
*/
public class LocationsManagerTest extends H2HJUnitTest {
private static List<NetworkManager> network;
@BeforeClass
public static void initTest() throws Exception {
testClass = LocationsManagerTest.class;
beforeClass();
network = NetworkTestUtil.createNetwork(DEFAULT_NETWORK_SIZE);
}
@Test
public void testRepair() throws Exception {
NetworkManager node = NetworkTestUtil.getRandomNode(network);
UseCaseTestUtil.registerAndLogin(generateRandomCredentials(), node, tempFolder.newFolder());
Locations repaired = node.getSession().getLocationsManager().repairLocations();
Assert.assertNotNull(repaired);
Assert.assertEquals(0, repaired.getPeerAddresses().size());
}
@AfterClass
public static void cleanAfterClass() {
NetworkTestUtil.shutdownNetwork(network);
afterClass();
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.network.data.vdht;
import java.security.KeyPair;
import org.hive2hive.core.H2HConstants;
import org.hive2hive.core.exceptions.GetFailedException;
import org.hive2hive.core.exceptions.PutFailedException;
import org.hive2hive.core.model.versioned.Locations;
import org.hive2hive.core.network.data.DataManager;
import org.hive2hive.core.network.data.DataManager.H2HPutStatus;
import org.hive2hive.core.network.data.parameters.Parameters;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Wrapper for the {@link VersionManager} for the Locations
*
* @author Nico
*
*/
public class LocationsManager {
private static final Logger logger = LoggerFactory.getLogger(LocationsManager.class);
private final KeyPair protectionKeys;
private final VersionManager<Locations> versionManager;
private final DataManager dataManager;
private final String userId;
public LocationsManager(DataManager dataManager, String userId, KeyPair protectionKeys) {
this.dataManager = dataManager;
this.userId = userId;
this.protectionKeys = protectionKeys;
versionManager = new VersionManager<Locations>(dataManager, userId, H2HConstants.USER_LOCATIONS);
}
public void put(Locations locations) throws PutFailedException {
versionManager.put(locations, protectionKeys);
}
public Locations get() throws GetFailedException {
return versionManager.get();
}
/**
* The locations file might have a conflict or is missing during the login. Here we try to repair it.
* Only call this if the locations are gone or ongoing version forks are detected. All entries of old
* Locations artifacts are deleted.
*
* @return the new locations or <code>null</code> if it failed
*/
public Locations repairLocations() {
Parameters removeParams = new Parameters().setContentKey(H2HConstants.USER_LOCATIONS).setLocationKey(userId)
.setProtectionKeys(protectionKeys);
logger.info("Start repairing the locations of user {}", userId);
if (dataManager.remove(removeParams)) {
logger.debug("Removed old locations of user {}", userId);
} else {
logger.warn("Failed to remove the old locations of user {}", userId);
}
Locations locations = new Locations(userId);
locations.generateVersionKey();
Parameters addParams = new Parameters().setLocationKey(userId).setContentKey(H2HConstants.USER_LOCATIONS)
.setVersionKey(locations.getVersionKey()).setBasedOnKey(locations.getBasedOnKey())
.setNetworkContent(locations).setProtectionKeys(protectionKeys).setTTL(locations.getTimeToLive());
if (dataManager.put(addParams) == H2HPutStatus.OK) {
logger.debug("Successfully repaired the locations of user {}", userId);
return locations;
} else {
logger.warn("Could not put the repaired locations of user {}", userId);
return null;
}
}
}
```
|
```package org.hive2hive.core.file;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import java.util.Random;
import org.apache.commons.io.FileUtils;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.model.Chunk;
import org.hive2hive.core.utils.FileTestUtil;
import org.hive2hive.core.utils.TestFileConfiguration;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* Test the file chunk util used for the H2H node.
*
* @author Nico
*
*/
public class FileChunkUtilTest extends H2HJUnitTest {
private static File parent;
@BeforeClass
public static void initTest() throws Exception {
parent = tempFolder.newFolder();
testClass = FileChunkUtilTest.class;
beforeClass();
}
@AfterClass
public static void cleanAfterClass() {
afterClass();
}
@Test
public void testGetNumberOfChunksRandom() throws IOException {
Random rnd = new Random();
for (int i = 0; i < 10; i++) {
int genNOC = rnd.nextInt(100) + 1; // avoid 0's
File randomFile = FileTestUtil.createFileRandomContent(genNOC, parent);
int resNOC = FileChunkUtil.getNumberOfChunks(randomFile, TestFileConfiguration.CHUNK_SIZE);
assertEquals(genNOC, resNOC);
randomFile.deleteOnExit(); // cleanup
}
}
@Test
public void testGetNumberOfChunksEmpty() throws IOException {
File file = new File(parent, randomString());
FileUtils.write(file, "");
assertEquals(1, FileChunkUtil.getNumberOfChunks(file, TestFileConfiguration.CHUNK_SIZE));
assertEquals(1, FileChunkUtil.getNumberOfChunks(file, TestFileConfiguration.CHUNK_SIZE / 2));
file.deleteOnExit(); // clenaup
}
@Test
public void testGetNumberOfChunksNotExisting() {
File file = new File(parent, randomString());
assertEquals(0, FileChunkUtil.getNumberOfChunks(file, TestFileConfiguration.CHUNK_SIZE));
}
@Test
public void testGetNumberOfChunksNull() {
assertEquals(0, FileChunkUtil.getNumberOfChunks(null, TestFileConfiguration.CHUNK_SIZE));
}
@Test
public void testGetNumberOfChunksSizeZero() throws IOException {
File file = new File(parent, randomString());
FileUtils.write(file, "test");
assertEquals(0, FileChunkUtil.getNumberOfChunks(file, 0));
file.deleteOnExit(); // clenaup
}
@Test
public void testGetNumberOfChunksSizeNegative() throws IOException {
File file = new File(parent, randomString());
FileUtils.write(file, "test");
assertEquals(0, FileChunkUtil.getNumberOfChunks(file, -1 * TestFileConfiguration.CHUNK_SIZE));
file.deleteOnExit(); // clenaup
}
@Test
public void testGetChunkRandom() throws IOException {
Random rnd = new Random();
for (int i = 0; i < 10; i++) {
int genNOC = rnd.nextInt(100) + 2; // avoid 0's
File randomFile = FileTestUtil.createFileRandomContent(genNOC, parent);
// get chunk 0 ... n-1
int chosenChunk = rnd.nextInt(genNOC - 1); // index starts at 0
Chunk chunk = FileChunkUtil.getChunk(randomFile, TestFileConfiguration.CHUNK_SIZE, chosenChunk, randomString());
assertEquals(TestFileConfiguration.CHUNK_SIZE, chunk.getSize());
assertEquals(chosenChunk, chunk.getOrder());
// get last chunk n
int lastChunkIndex = genNOC - 1; // index starts at 0
chunk = FileChunkUtil.getChunk(randomFile, TestFileConfiguration.CHUNK_SIZE, lastChunkIndex, randomString());
assertTrue(TestFileConfiguration.CHUNK_SIZE > chunk.getSize());
assertEquals(lastChunkIndex, chunk.getOrder());
randomFile.deleteOnExit(); // cleanup
}
}
@Test
public void testGetChunkEmpty() throws IOException {
File file = new File(parent, randomString());
FileUtils.write(file, "");
Chunk chunk = FileChunkUtil.getChunk(file, TestFileConfiguration.CHUNK_SIZE, 0, randomString());
assertEquals(0, chunk.getSize());
assertEquals(0, chunk.getOrder());
file.deleteOnExit(); // clenaup
}
@Test(expected = IOException.class)
public void testGetChunkNotExisting() throws IOException {
File file = new File(parent, randomString());
FileChunkUtil.getChunk(file, TestFileConfiguration.CHUNK_SIZE, 0, randomString());
}
@Test(expected = IOException.class)
public void testGetChunkNull() throws IOException {
FileChunkUtil.getChunk(null, TestFileConfiguration.CHUNK_SIZE, 0, randomString());
}
@Test(expected = IOException.class)
public void testGetChunkNegativeChunkSize() throws IOException {
File file = new File(parent, randomString());
FileChunkUtil.getChunk(file, -1 * TestFileConfiguration.CHUNK_SIZE, 0, randomString());
}
@Test(expected = IOException.class)
public void testGetChunkNegativeOrderNumber() throws IOException {
File file = new File(parent, randomString());
FileChunkUtil.getChunk(file, TestFileConfiguration.CHUNK_SIZE, -10, randomString());
}
@Test
public void testGetChunkTooHighIndex() throws IOException {
File file = new File(parent, randomString());
FileUtils.write(file, "test");
Chunk chunk = FileChunkUtil.getChunk(file, TestFileConfiguration.CHUNK_SIZE, 100, randomString());
assertNull(chunk);
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.file;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.List;
import org.apache.commons.io.FileUtils;
import org.hive2hive.core.model.Chunk;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class FileChunkUtil {
private static final Logger logger = LoggerFactory.getLogger(FileChunkUtil.class);
private FileChunkUtil() {
// only static methods
}
/**
* Calculates the number of chunks. This depends on the file size and the chunk size
*
* @param file the file to chunk
* @param chunkSize the size of an individual chunk
* @return the number of chunks, if the file is empty, 1 is returned. If file is not existing, 0 is
* returned. In case the given chunkSize is smaller or equal to zero, 0 is returned
*/
public static int getNumberOfChunks(File file, int chunkSize) {
if (file == null || !file.exists()) {
// no chunk needed
return 0;
} else if (chunkSize <= 0) {
// don't divide by 0
return 0;
}
long fileSize = FileUtil.getFileSize(file);
if (fileSize == 0) {
// special case
return 1;
}
return (int) Math.ceil((double) fileSize / Math.abs(chunkSize));
}
/**
* Returns the chunk of a given file.
*
* @param file the file to chunk
* @param chunkSize the maximum size of a single chunk. If the end of the file has been reached before,
* the returned chunk can be smaller.
* @param chunkNumber the index of the chunk, starting at 0. When giving 0, the first chunk is read. This
* parameter is similar to the offset.
* @param chunkId the id of the chunk which should be returned
* @return the chunk or null if no data could be read with the given parameter
* @throws IOException if the file cannot be read
*/
public static Chunk getChunk(File file, int chunkSize, int chunkNumber, String chunkId) throws IOException {
if (file == null || !file.exists()) {
throw new IOException("File does not exist");
} else if (chunkSize <= 0) {
throw new IOException("Chunk size cannot be smaller or equal to 0");
} else if (chunkNumber < 0) {
throw new IOException("Chunk number cannot be smaller than 0");
}
if (FileUtil.getFileSize(file) == 0 && chunkNumber == 0) {
// special case: file exists but is empty.
// return an empty chunk
return new Chunk(chunkId, new byte[0], 0);
}
int read = 0;
long offset = chunkSize * (long) chunkNumber;
byte[] data = new byte[chunkSize];
// read the next chunk of the file considering the offset
RandomAccessFile rndAccessFile = new RandomAccessFile(file, "r");
rndAccessFile.seek(offset);
read = rndAccessFile.read(data);
rndAccessFile.close();
if (read > 0) {
// the byte-Array may contain many empty slots if last chunk. Truncate it
data = truncateData(data, read);
return new Chunk(chunkId, data, chunkNumber);
} else {
return null;
}
}
/**
* Truncates a byte array
*
* @param data
* @param read
* @return a shorter byte array
*/
private static byte[] truncateData(byte[] data, int numOfBytes) {
// shortcut
if (data.length == numOfBytes) {
return data;
} else {
byte[] truncated = new byte[numOfBytes];
for (int i = 0; i < truncated.length; i++) {
truncated[i] = data[i];
}
return truncated;
}
}
/**
* Reassembling of multiple file parts to a single file. Note that the file parts need to be sorted
* beforehand
*
* @param fileParts the sorted file parts.
* @param destination the destination
* @throws IOException in case the files could not be read or written.
*/
public static void reassembly(List<File> fileParts, File destination) throws IOException {
if (fileParts == null || fileParts.isEmpty()) {
throw new IllegalArgumentException("File parts can't be null.");
} else if (fileParts.isEmpty()) {
throw new IllegalArgumentException("File parts can't be empty.");
} else if (destination == null) {
throw new IllegalArgumentException("Destination can't be null");
}
if (destination.exists()) {
// overwrite
if (destination.delete()) {
logger.warn("Destination gets overwritten. destination = '{}'", destination);
} else {
throw new IOException(String.format("Couldn't overwrite destination. destination = '%s'", destination));
}
}
// The file parts are assembled where they are located, then moved to the destination
File assembled = new File(fileParts.get(0).getParentFile(), fileParts.get(0).getName().concat("_assembled"));
logger.trace("Assemble file to {}", assembled.getPath());
for (File filePart : fileParts) {
// copy file parts to the new location, append
FileUtils.writeByteArrayToFile(assembled, FileUtils.readFileToByteArray(filePart), true);
if (!filePart.delete()) {
logger.warn("Couldn't delete temporary file part. filePart = '{}'", filePart);
}
}
FileUtils.moveFile(assembled, destination);
}
}
```
|
```package org.hive2hive.core.events;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import java.util.List;
import org.hive2hive.core.events.framework.interfaces.file.IFileEvent;
import org.hive2hive.core.events.framework.interfaces.file.IFileMoveEvent;
import org.hive2hive.core.exceptions.NoPeerConnectionException;
import org.hive2hive.core.exceptions.NoSessionException;
import org.hive2hive.core.utils.UseCaseTestUtil;
import org.junit.Test;
public class FileMoveEventsTest extends FileEventsTest {
static {
testClass = FileMoveEventsTest.class;
}
@Test
public void testFileMoveEvent() throws NoPeerConnectionException, IOException, NoSessionException {
// upload a file from machine A
File file = createAndAddFile(rootA, clientA);
File dst = new File(rootA, randomString(12));
waitForNumberOfEvents(1);
listener.getEvents().clear();
UseCaseTestUtil.moveFile(clientA, file, dst);
waitForNumberOfEvents(1);
List<IFileEvent> events = listener.getEvents();
assertEventType(events, IFileMoveEvent.class);
assertTrue(events.size() == 1);
// compare src/dst paths of A and B
IFileMoveEvent e = (IFileMoveEvent) events.get(0);
assertEqualsRelativePaths(file, e.getSrcFile());
assertEqualsRelativePaths(dst, e.getDstFile());
assertTrue(e.isFile());
assertFalse(e.isFolder());
}
@Test
public void testEmptyFolderMoveEvent() throws NoPeerConnectionException, IOException, NoSessionException {
// upload a folder from machine A
File folder = createAndAddFolder(rootA, clientA);
File dst = new File(rootA, randomString(12));
waitForNumberOfEvents(1);
listener.getEvents().clear();
UseCaseTestUtil.moveFile(clientA, folder, dst);
waitForNumberOfEvents(1);
List<IFileEvent> events = listener.getEvents();
assertEventType(events, IFileMoveEvent.class);
assertTrue(events.size() == 1);
// compare src/dst paths of A and B
IFileMoveEvent e = (IFileMoveEvent) events.get(0);
assertEqualsRelativePaths(folder, e.getSrcFile());
assertEqualsRelativePaths(dst, e.getDstFile());
assertFalse(e.isFile());
assertTrue(e.isFolder());
}
@Test
public void testFolderWithFilesMoveEvent() throws NoPeerConnectionException, IOException, NoSessionException {
List<File> files = createAndAddFolderWithFiles(rootA, clientA);
File folder = files.get(0);
File dst = new File(rootA, randomString(12));
waitForNumberOfEvents(files.size());
listener.getEvents().clear();
UseCaseTestUtil.moveFile(clientA, folder, dst);
waitForNumberOfEvents(1);
List<IFileEvent> events = listener.getEvents();
assertEventType(events, IFileMoveEvent.class);
assertTrue(events.size() == 1);
// compare src/dst paths of A and B
IFileMoveEvent e = (IFileMoveEvent) events.get(0);
assertEqualsRelativePaths(folder, e.getSrcFile());
assertEqualsRelativePaths(dst, e.getDstFile());
assertFalse(e.isFile());
assertTrue(e.isFolder());
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.events.framework.interfaces.file;
import java.io.File;
public interface IFileMoveEvent extends IFileEvent {
File getSrcFile();
File getDstFile();
}
```
|
```package org.hive2hive.core.model.versioned;
import static org.junit.Assert.assertEquals;
import net.tomp2p.peers.Number160;
import org.hive2hive.core.H2HJUnitTest;
import org.hive2hive.core.model.UserCredentialsTest;
import org.junit.BeforeClass;
import org.junit.Test;
public class BaseVersionedNetworkContentTest extends H2HJUnitTest {
@BeforeClass
public static void initTest() throws Exception {
testClass = UserCredentialsTest.class;
beforeClass();
}
@Test
public void testGenerateVersions() {
TestVersionedContent v0 = new TestVersionedContent();
assertEquals(Number160.ZERO, v0.getVersionKey());
TestVersionedContent v1 = new TestVersionedContent();
v1.setVersionKey(v0.getVersionKey());
v1.generateVersionKey();
assertEquals(-1, v0.getVersionKey().compareTo(v1.getVersionKey()));
TestVersionedContent v2 = new TestVersionedContent();
v2.setVersionKey(v1.getVersionKey());
v2.generateVersionKey();
assertEquals(-1, v1.getVersionKey().compareTo(v2.getVersionKey()));
}
private class TestVersionedContent extends BaseVersionedNetworkContent {
private static final long serialVersionUID = 1L;
@Override
protected int getContentHash() {
return super.hashCode();
}
@Override
public int getTimeToLive() {
return 100;
}
}
}
```
|
Please help me generate a test for this class.
|
```package org.hive2hive.core.model.versioned;
import net.tomp2p.peers.Number160;
import org.hive2hive.core.model.BaseNetworkContent;
/**
* All data of <code>Hive2Hive</code> which has to be stored in the DHT and are frequently manipulated are
* using this wrapper.
*
* @author Seppi
*/
public abstract class BaseVersionedNetworkContent extends BaseNetworkContent {
private static final long serialVersionUID = 8206000167141687813L;
/**
* Some data has a version key (used to differentiate versions). Default value.
*/
private Number160 versionKey = Number160.ZERO;
/**
* Some data is based on other data. Default value.
*/
private Number160 basedOnKey = Number160.ZERO;
/**
* @return a hash of the content (or at least its identifier)
*/
protected abstract int getContentHash();
public Number160 getVersionKey() {
return versionKey;
}
public void setVersionKey(Number160 versionKey) {
this.versionKey = versionKey;
}
public Number160 getBasedOnKey() {
return basedOnKey;
}
public void setBasedOnKey(Number160 basedOnKey) {
this.basedOnKey = basedOnKey;
}
public void generateVersionKey() {
// re-attach version keys
basedOnKey = versionKey;
// increase counter
long counter = basedOnKey.timestamp() + 1;
// create new version key based on increased counter and hash
versionKey = new Number160(counter, new Number160(getContentHash()).number96());
}
}
```
|