rife2/bld-jacoco-report
rife2/bld-jacoco-report
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add missing options getters and tests

Browse source
This commit is contained in:
Erik C. Thauvin 2025-05-19 11:49:51 -07:00
parent 9f9fdac82e
commit 35f41fb681
Signed by: erik
GPG key ID: 776702A6A2DA330E
1 changed files with 180 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

241
src/test/java/rife/bld/extension/JacocoReportOperationTest.java
View file

@ -38,16 +38,16 @@ import static org.assertj.core.api.Assertions.assertThatCode;
@SuppressWarnings("PMD.AvoidDuplicateLiterals") @SuppressWarnings("PMD.AvoidDuplicateLiterals")
class JacocoReportOperationTest { class JacocoReportOperationTest {
final File csv; final File csvFile;
final File html; final File htmlDir;
final Path tempDir; final Path tempDir;
final File xml; final File xmlFile;
JacocoReportOperationTest() throws IOException { JacocoReportOperationTest() throws IOException {
tempDir = Files.createTempDirectory("jacoco-test"); tempDir = Files.createTempDirectory("jacoco-test");
csv = (new File(tempDir.toFile(), "jacoco.csv")); csvFile = (new File(tempDir.toFile(), "jacoco.csv"));
html = (new File(tempDir.toFile(), "html")); htmlDir = (new File(tempDir.toFile(), "html"));
xml = (new File(tempDir.toFile(), "jacoco.xml")); xmlFile = (new File(tempDir.toFile(), "jacoco.xml"));
} }
static void deleteOnExit(File folder) { static void deleteOnExit(File folder) {
@ -84,12 +84,34 @@ class JacocoReportOperationTest {
@Nested @Nested
@DisplayName("Execute Tests") @DisplayName("Execute Tests")
class ExecuteTests { class ExecuteTests {
@Test
void execute() throws Exception {
newJacocoReportOperation().execute();
assertThat(csvFile).exists();
assertThat(htmlDir).isDirectory();
assertThat(xmlFile).exists();
try (var softly = new AutoCloseableSoftAssertions()) {
try (var lines = Files.lines(xmlFile.toPath())) {
softly.assertThat(lines.anyMatch(s ->
s.contains("<counter type=\"INSTRUCTION\" missed=\"0\" covered=\"3\"/>"))).isTrue();
}
}
assertThat(Path.of(htmlDir.getPath(), "com.example", "Examples.java.html")).exists();
}
@Test
void executeFailure() {
var op = new JacocoReportOperation().fromProject(new Project());
assertThatCode(op::execute).isInstanceOf(ExitStatusException.class);
}
JacocoReportOperation newJacocoReportOperation() { JacocoReportOperation newJacocoReportOperation() {
var op = new JacocoReportOperation() var op = new JacocoReportOperation()
.fromProject(new Project()) .fromProject(new Project())
.csv(csv) .csv(csvFile)
.html(html) .html(htmlDir)
.xml(xml) .xml(xmlFile)
.classFiles(new File("src/test/resources/Examples.class")) .classFiles(new File("src/test/resources/Examples.class"))
.sourceFiles(new File("examples/src/main/java")) .sourceFiles(new File("examples/src/main/java"))
.execFiles(new File("src/test/resources/jacoco.exec")); .execFiles(new File("src/test/resources/jacoco.exec"));
@ -98,35 +120,114 @@ class JacocoReportOperationTest {
return op; return op;
} }
}
@DisplayName("Options Tests")
class OptionsTests {
public static final String FOO = "foo";
private final File fooFile = new File(FOO);
@Test @Test
void execute() throws Exception { void csvAsFile() {
newJacocoReportOperation().execute(); var op = new JacocoReportOperation();
op.csv(fooFile);
assertThat(csv).exists(); assertThat(op.csv()).isEqualTo(fooFile);
assertThat(html).isDirectory();
assertThat(xml).exists();
try (var softly = new AutoCloseableSoftAssertions()) {
try (var lines = Files.lines(xml.toPath())) {
softly.assertThat(lines.anyMatch(s ->
s.contains("<counter type=\"INSTRUCTION\" missed=\"0\" covered=\"3\"/>"))).isTrue();
}
}
assertThat(Path.of(html.getPath(), "com.example", "Examples.java.html")).exists();
} }
@Test @Test
void executeFailure() { void csvAsPath() {
var op = new JacocoReportOperation().fromProject(new Project()); var fooPath = fooFile.toPath();
assertThatCode(op::execute).isInstanceOf(ExitStatusException.class); var op = new JacocoReportOperation();
op.csv(fooPath);
assertThat(op.csv()).isEqualTo(fooFile);
}
@Test
void csvAsString() {
var op = new JacocoReportOperation();
op.csv(FOO);
assertThat(op.csv()).isEqualTo(fooFile);
}
@Test
void htmlAsFile() {
var op = new JacocoReportOperation();
op.html(fooFile);
assertThat(op.html()).isEqualTo(fooFile);
}
@Test
void htmlAsPath() {
var fooPath = fooFile.toPath();
var op = new JacocoReportOperation();
op.html(fooPath);
assertThat(op.html()).isEqualTo(fooFile);
}
@Test
void htmlAsString() {
var op = new JacocoReportOperation();
op.html(FOO);
assertThat(op.html()).isEqualTo(fooFile);
}
@Test
void quietIsFalse() {
var op = new JacocoReportOperation();
op.quiet(false);
assertThat(op.isQuiet()).isFalse();
}
@Test
void quietIsTrue() {
var op = new JacocoReportOperation();
op.quiet(true);
assertThat(op.isQuiet()).isTrue();
}
@Test
void reportName() {
var op = new JacocoReportOperation();
op.name(FOO);
assertThat(op.name()).isEqualTo(FOO);
}
@Test
void tabWidth() {
var op = new JacocoReportOperation();
op.tabWidth(4);
assertThat(op.tabWidth()).isEqualTo(4);
}
@Test
void xmlAsFile() {
var op = new JacocoReportOperation();
op.xml(fooFile);
assertThat(op.xml()).isEqualTo(fooFile);
}
@Test
void xmlAsPath() {
var fooPath = fooFile.toPath();
var op = new JacocoReportOperation();
op.xml(fooPath);
assertThat(op.xml()).isEqualTo(fooFile);
}
@Test
void xmlAsString() {
var op = new JacocoReportOperation();
op.xml(FOO);
assertThat(op.xml()).isEqualTo(fooFile);
} }
} }
@Nested @Nested
@DisplayName("File Operation Tests") @DisplayName("File Operation Tests")
class FilesOperationTests { class FilesOperationTests {
private final File bar = new File("bar"); private final File barFile = new File("bar");
private final File foo = new File("foo"); private final File fooFile = new File("foo");
private final JacocoReportOperation op = new JacocoReportOperation(); private final JacocoReportOperation op = new JacocoReportOperation();
@Nested @Nested
@ -135,144 +236,162 @@ class JacocoReportOperationTest {
@Test @Test
void classFilesAsFileArray() { void classFilesAsFileArray() {
op.classFiles().clear(); op.classFiles().clear();
op.classFiles(foo, bar); assertThat(op.classFiles()).isEmpty();
assertThat(op.classFiles()).contains(foo, bar); op.classFiles(fooFile, barFile);
assertThat(op.classFiles()).contains(fooFile, barFile);
} }
@Test @Test
void classFilesAsFileList() { void classFilesAsFileList() {
op.classFiles().clear(); op.classFiles().clear();
op.classFiles(List.of(foo, bar)); assertThat(op.classFiles()).isEmpty();
assertThat(op.classFiles()).contains(foo, bar); op.classFiles(List.of(fooFile, barFile));
assertThat(op.classFiles()).contains(fooFile, barFile);
} }
@Test @Test
void classFilesAsPathArray() { void classFilesAsPathArray() {
op.classFiles().clear(); op.classFiles().clear();
op.classFiles(foo.toPath(), bar.toPath()); assertThat(op.classFiles()).isEmpty();
assertThat(op.classFiles()).contains(foo, bar); op.classFiles(fooFile.toPath(), barFile.toPath());
assertThat(op.classFiles()).contains(fooFile, barFile);
} }
@Test @Test
void classFilesAsPathList() { void classFilesAsPathList() {
op.classFiles().clear(); op.classFiles().clear();
op.classFilesPaths(List.of(foo.toPath(), bar.toPath())); assertThat(op.classFiles()).isEmpty();
assertThat(op.classFiles()).contains(foo, bar); op.classFilesPaths(List.of(fooFile.toPath(), barFile.toPath()));
assertThat(op.classFiles()).contains(fooFile, barFile);
} }
@Test @Test
void classFilesAsStringArray() { void classFilesAsStringArray() {
op.classFiles().clear(); op.classFiles().clear();
assertThat(op.classFiles()).isEmpty();
op.classFiles("foo", "bar"); op.classFiles("foo", "bar");
assertThat(op.classFiles()).contains(foo, bar); assertThat(op.classFiles()).contains(fooFile, barFile);
} }
@Test @Test
void classFilesAsStringList() { void classFilesAsStringList() {
op.classFiles().clear(); op.classFiles().clear();
assertThat(op.classFiles()).isEmpty();
op.classFilesStrings(List.of("foo", "bar")); op.classFilesStrings(List.of("foo", "bar"));
assertThat(op.classFiles()).contains(foo, bar); assertThat(op.classFiles()).contains(fooFile, barFile);
} }
} }
@Nested @Nested
@DisplayName("Exec Files Tests") @DisplayName("Exec Files Tests")
class ExecFilesTests { class ExecFilesTests {
private final File bar = new File("bar"); private final File barFile = new File("bar");
private final File foo = new File("foo"); private final File fooFile = new File("foo");
private final JacocoReportOperation op = new JacocoReportOperation(); private final JacocoReportOperation op = new JacocoReportOperation();
@Test @Test
void execFilesAsFileArray() { void execFilesAsFileArray() {
op.execFiles().clear(); op.execFiles().clear();
op.execFiles(foo, bar); assertThat(op.execFiles()).isEmpty();
assertThat(op.execFiles()).contains(foo, bar); op.execFiles(fooFile, barFile);
assertThat(op.execFiles()).contains(fooFile, barFile);
} }
@Test @Test
void execFilesAsFileList() { void execFilesAsFileList() {
op.execFiles().clear(); op.execFiles().clear();
op.execFiles(List.of(foo, bar)); assertThat(op.execFiles()).isEmpty();
assertThat(op.execFiles()).contains(foo, bar); op.execFiles(List.of(fooFile, barFile));
assertThat(op.execFiles()).contains(fooFile, barFile);
} }
@Test @Test
void execFilesAsPathArray() { void execFilesAsPathArray() {
op.execFiles().clear(); op.execFiles().clear();
op.execFiles(foo.toPath(), bar.toPath()); assertThat(op.execFiles()).isEmpty();
assertThat(op.execFiles()).contains(foo, bar); op.execFiles(fooFile.toPath(), barFile.toPath());
assertThat(op.execFiles()).contains(fooFile, barFile);
} }
@Test @Test
void execFilesAsPathList() { void execFilesAsPathList() {
op.execFiles().clear(); op.execFiles().clear();
op.execFilesPaths(List.of(foo.toPath(), bar.toPath())); assertThat(op.execFiles()).isEmpty();
assertThat(op.execFiles()).contains(foo, bar); op.execFilesPaths(List.of(fooFile.toPath(), barFile.toPath()));
assertThat(op.execFiles()).contains(fooFile, barFile);
op.execFiles().clear(); op.execFiles().clear();
} }
@Test @Test
void execFilesAsStringArray() { void execFilesAsStringArray() {
op.execFiles().clear(); op.execFiles().clear();
assertThat(op.execFiles()).isEmpty();
op.execFiles("foo", "bar"); op.execFiles("foo", "bar");
assertThat(op.execFiles()).contains(foo, bar); assertThat(op.execFiles()).contains(fooFile, barFile);
} }
@Test @Test
void execFilesAsStringList() { void execFilesAsStringList() {
op.execFiles().clear(); op.execFiles().clear();
assertThat(op.execFiles()).isEmpty();
op.execFilesStrings(List.of("foo", "bar")); op.execFilesStrings(List.of("foo", "bar"));
assertThat(op.execFiles()).contains(foo, bar); assertThat(op.execFiles()).contains(fooFile, barFile);
} }
} }
@Nested @Nested
@DisplayName("Source Files Tests") @DisplayName("Source Files Tests")
class SourceFilesTests { class SourceFilesTests {
private final File bar = new File("bar"); private final File barFile = new File("bar");
private final File foo = new File("foo"); private final File fooFile = new File("foo");
private final JacocoReportOperation op = new JacocoReportOperation(); private final JacocoReportOperation op = new JacocoReportOperation();
@Test @Test
void sourceFilesAsFileArray() { void sourceFilesAsFileArray() {
op.sourceFiles().clear(); op.sourceFiles().clear();
op.sourceFiles(foo, bar); assertThat(op.sourceFiles()).isEmpty();
assertThat(op.sourceFiles()).as("File...").contains(foo, bar); op.sourceFiles(fooFile, barFile);
assertThat(op.sourceFiles()).as("File...").contains(fooFile, barFile);
} }
@Test @Test
void sourceFilesAsFileList() { void sourceFilesAsFileList() {
op.sourceFiles().clear(); op.sourceFiles().clear();
op.sourceFiles(List.of(foo, bar)); assertThat(op.sourceFiles()).isEmpty();
assertThat(op.sourceFiles()).as("File...").contains(foo, bar); op.sourceFiles(List.of(fooFile, barFile));
assertThat(op.sourceFiles()).as("File...").contains(fooFile, barFile);
} }
@Test @Test
void sourceFilesAsPathList() { void sourceFilesAsPathList() {
op.sourceFiles().clear(); op.sourceFiles().clear();
op.sourceFilesPaths(List.of(foo.toPath(), bar.toPath())); assertThat(op.sourceFiles()).isEmpty();
assertThat(op.sourceFiles()).as("Path...").contains(foo, bar); op.sourceFilesPaths(List.of(fooFile.toPath(), barFile.toPath()));
assertThat(op.sourceFiles()).as("Path...").contains(fooFile, barFile);
} }
@Test @Test
void sourceFilesAsStringArray() { void sourceFilesAsStringArray() {
op.sourceFiles().clear(); op.sourceFiles().clear();
assertThat(op.sourceFiles()).isEmpty();
op.sourceFiles("foo", "bar"); op.sourceFiles("foo", "bar");
assertThat(op.sourceFiles()).as("String...").contains(foo, bar); assertThat(op.sourceFiles()).as("String...").contains(fooFile, barFile);
} }
@Test @Test
void sourceFilesAsStringList() { void sourceFilesAsStringList() {
op.sourceFiles().clear(); op.sourceFiles().clear();
assertThat(op.sourceFiles()).isEmpty();
op.sourceFilesStrings(List.of("foo", "bar")); op.sourceFilesStrings(List.of("foo", "bar"));
assertThat(op.sourceFiles()).as("List(String...)").contains(foo, bar); assertThat(op.sourceFiles()).as("List(String...)").contains(fooFile, barFile);
} }
@Test @Test
void sourceFilesPathArray() { void sourceFilesPathArray() {
op.sourceFiles().clear(); op.sourceFiles().clear();
op.sourceFiles(foo.toPath(), bar.toPath()); assertThat(op.sourceFiles()).isEmpty();
assertThat(op.sourceFiles()).as("Path...").contains(foo, bar); op.sourceFiles(fooFile.toPath(), barFile.toPath());
assertThat(op.sourceFiles()).as("Path...").contains(fooFile, barFile);
} }
} }
} }