This is an automated email from the ASF dual-hosted git repository.
yamer pushed a commit to branch main
in repository
https://gitbox.apache.org/repos/asf/incubator-kie-kogito-runtimes.git
The following commit(s) were added to refs/heads/main by this push:
new 28984ce104 kie-issues#2193: Preliminary changes to enable Gradle and
improvements to `kogito-maven-plugin` (#4166)
28984ce104 is described below
commit 28984ce104678c6b0beb96e54809de20fc6e5dba
Author: Yeser Amer <[email protected]>
AuthorDate: Thu Jan 15 12:10:41 2026 +0100
kie-issues#2193: Preliminary changes to enable Gradle and improvements to
`kogito-maven-plugin` (#4166)
* Improvements to code generation manager and plugin
* Minor
* Revert Maven plugin testing
* minor
* minor
* minor
* minor
* change request
* change request
* tests added
* tests added
* logback tests added.
* logback tests added.
* logback tests added.
* Improve compatibility with JDK 21+
* Revert Maven surefire plugin configuration for dynamic
---
.../kie/kogito/codegen/manager/BuilderManager.java | 19 +-
.../kie/kogito/codegen/manager/CompilerHelper.java | 63 +---
.../codegen/manager/GenerateModelHelper.java | 39 +--
.../codegen/manager/GeneratedFileManager.java | 131 ++++++++
.../codegen/manager/util/CodeGenManagerUtil.java | 26 --
.../codegen/manager/GeneratedFileManagerTest.java | 337 +++++++++++++++++++++
.../src/test/resources/logback-test.xml | 40 +++
kogito-maven-plugin-test/pom.xml | 1 -
kogito-maven-plugin/README.md | 1 -
kogito-maven-plugin/pom.xml | 1 +
.../kie/kogito/maven/plugin/AbstractKieMojo.java | 21 +-
.../kie/kogito/maven/plugin/GenerateModelMojo.java | 22 +-
.../kogito/maven/plugin/GenerateModelMojoTest.java | 19 +-
13 files changed, 584 insertions(+), 136 deletions(-)
diff --git
a/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/BuilderManager.java
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/BuilderManager.java
index 23d1fab8b6..a59a6149ad 100644
---
a/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/BuilderManager.java
+++
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/BuilderManager.java
@@ -57,7 +57,6 @@ public class BuilderManager {
String jsonSchemaVersion,
boolean generatePartial,
boolean enablePersistence,
- boolean onDemand,
boolean keepSources,
List<String> runtimeClassPathElements,
CodeGenManagerUtil.Framework framework,
@@ -65,6 +64,7 @@ public class BuilderManager {
}
public static void build(BuildInfo buildInfo) throws MalformedURLException
{
+ executeConfigurationLog(buildInfo);
LOGGER.info("Building project: {}:{}:{}", buildInfo.projectGroupId(),
buildInfo.projectArtifactId(), buildInfo.projectVersion());
CodeGenManagerUtil.setSystemProperties(buildInfo.properties());
ClassLoader projectClassLoader =
CodeGenManagerUtil.projectClassLoader(buildInfo.projectFilesUris());
@@ -76,6 +76,21 @@ public class BuilderManager {
LOGGER.info("Project build done");
}
+ static void executeConfigurationLog(BuildInfo buildInfo) {
+ LOGGER.info("========================================");
+ LOGGER.info(" Kogito Code Generation Configuration");
+ LOGGER.info("========================================");
+ LOGGER.info(" Java Version : {}", buildInfo.javaVersion());
+ LOGGER.info(" Source Encoding : {}",
buildInfo.javaSourceEncoding());
+ LOGGER.info(" Base Directory : {}",
buildInfo.projectBaseAbsolutePath());
+ LOGGER.info(" Output Directory : {}", buildInfo.outputDirectory());
+ LOGGER.info(" JSON Schema Version : {}",
buildInfo.jsonSchemaVersion() != null ? buildInfo.jsonSchemaVersion() : "nd");
+ LOGGER.info(" Persistence Enabled : {}",
buildInfo.enablePersistence());
+ LOGGER.info(" Keep Sources : {}", buildInfo.keepSources());
+ LOGGER.info(" Framework : {}", buildInfo.framework());
+ LOGGER.info("========================================");
+ }
+
static KogitoBuildContext getKogitoBuildContext(ClassLoader
projectClassLoader, KogitoGAV kogitoGAV, KogitoBuildContextInfo
kogitoBuildContextInfo) {
return
CodeGenManagerUtil.discoverKogitoRuntimeContext(projectClassLoader,
kogitoBuildContextInfo.projectBaseAbsolutePath(), kogitoGAV,
new
CodeGenManagerUtil.ProjectParameters(kogitoBuildContextInfo.framework(), "",
"", "", "", kogitoBuildContextInfo.enablePersistence()),
@@ -83,7 +98,7 @@ public class BuilderManager {
try {
return
CodeGenManagerUtil.isClassNameInUrlClassLoader(kogitoBuildContextInfo.projectFilesUris(),
className);
} catch (MalformedURLException e) {
- throw new RuntimeException(e);
+ throw new IllegalArgumentException(e);
}
});
}
diff --git
a/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/CompilerHelper.java
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/CompilerHelper.java
index a0029ed77f..5e67d5a202 100644
---
a/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/CompilerHelper.java
+++
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/CompilerHelper.java
@@ -27,25 +27,17 @@ import java.util.stream.Collectors;
import org.drools.codegen.common.GeneratedFile;
import org.drools.codegen.common.GeneratedFileType;
-import org.drools.codegen.common.GeneratedFileWriter;
import org.drools.compiler.compiler.io.memory.MemoryFileSystem;
-import org.drools.util.PortablePath;
import org.kie.memorycompiler.CompilationProblem;
import org.kie.memorycompiler.CompilationResult;
import org.kie.memorycompiler.JavaCompiler;
import org.kie.memorycompiler.JavaCompilerFactory;
import org.kie.memorycompiler.JavaCompilerSettings;
import org.kie.memorycompiler.JavaConfiguration;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
public class CompilerHelper {
- private static final Logger LOGGER =
LoggerFactory.getLogger(CompilerHelper.class);
-
private static final JavaCompiler JAVA_COMPILER =
JavaCompilerFactory.loadCompiler(JavaConfiguration.CompilerType.NATIVE, "17");
- private static final GeneratedFileWriter.Builder
GENERATED_FILE_WRITER_BUILDER =
- GeneratedFileWriter.builder("kogito",
"kogito.codegen.resources.directory", "kogito.codegen.sources.directory");
public static final String SOURCES = "SOURCES";
public static final String RESOURCES = "RESOURCES";
@@ -72,53 +64,18 @@ public class CompilerHelper {
}
public static void compileAndDump(CompileInfo compileInfo) {
- compileAndDumpGeneratedSources(compileInfo);
- dumpResources(compileInfo.resources(), compileInfo.baseDir());
- }
-
- public static void compileAndDumpGeneratedSources(CompileInfo compileInfo)
{
- // Compile and write files
compileAndWriteClasses(compileInfo.generatedSources(),
compileInfo.projectClassLoader,
buildJavaCompilerSettings(compileInfo.runtimeClassPathElements,
compileInfo.javaSourceEncoding,
compileInfo.javaVersion),
- getGeneratedFileWriter(compileInfo.baseDir));
- // Dump resources
- writeFiles(compileInfo.generatedSources, compileInfo.baseDir);
- }
-
- public static void dumpResources(Collection<GeneratedFile> resources, Path
baseDir) {
- dumpResources(resources, baseDir.toFile());
- }
-
- public static void dumpResources(Collection<GeneratedFile> resources, File
baseDir) {
- writeFiles(resources, baseDir);
- }
-
- static void writeFiles(Collection<GeneratedFile> toWrite, File baseDir) {
- GeneratedFileWriter writer = getGeneratedFileWriter(baseDir);
- toWrite.forEach(generatedFile -> writeGeneratedFile(generatedFile,
writer));
- }
-
- static void writeFiles(Collection<GeneratedFile> toWrite, Path baseDir) {
- GeneratedFileWriter writer = getGeneratedFileWriter(baseDir);
- toWrite.forEach(generatedFile -> writeGeneratedFile(generatedFile,
writer));
- }
-
- static GeneratedFileWriter getGeneratedFileWriter(Path baseDir) {
- return GENERATED_FILE_WRITER_BUILDER.build(baseDir);
- }
-
- static void writeGeneratedFile(GeneratedFile generatedFile,
GeneratedFileWriter writer) {
- LOGGER.info("Writing compiled class: {}",
generatedFile.relativePath());
- writer.write(generatedFile);
+ compileInfo.baseDir().toPath());
}
static void compileAndWriteClasses(Collection<GeneratedFile>
generatedClasses,
ClassLoader classLoader,
JavaCompilerSettings javaCompilerSettings,
- GeneratedFileWriter fileWriter) {
+ Path baseDir) {
MemoryFileSystem srcMfs = new MemoryFileSystem();
MemoryFileSystem trgMfs = new MemoryFileSystem();
@@ -139,15 +96,15 @@ public class CompilerHelper {
.collect(Collectors.joining(",")));
}
- for (PortablePath path : trgMfs.getFilePaths()) {
- byte[] data = trgMfs.getBytes(path);
- writeGeneratedFile(new
GeneratedFile(GeneratedFileType.COMPILED_CLASS, path.asString(), data),
fileWriter);
- }
- }
- }
+ Collection<GeneratedFile> compiledClasses =
trgMfs.getFilePaths().stream()
+ .map(path -> new GeneratedFile(
+ GeneratedFileType.COMPILED_CLASS,
+ path.asString(),
+ trgMfs.getBytes(path)))
+ .toList();
- static GeneratedFileWriter getGeneratedFileWriter(File baseDir) {
- return
GENERATED_FILE_WRITER_BUILDER.build(Path.of(baseDir.getAbsolutePath()));
+ GeneratedFileManager.dumpGeneratedFiles(compiledClasses, baseDir);
+ }
}
static JavaCompilerSettings buildJavaCompilerSettings(List<String>
runtimeClassPathElements,
diff --git
a/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/GenerateModelHelper.java
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/GenerateModelHelper.java
index 23a569595d..6833634995 100644
---
a/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/GenerateModelHelper.java
+++
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/GenerateModelHelper.java
@@ -20,7 +20,6 @@ package org.kie.kogito.codegen.manager;
import java.io.File;
import java.util.Collection;
-import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
@@ -30,9 +29,6 @@ import org.kie.kogito.codegen.api.context.KogitoBuildContext;
import org.kie.kogito.codegen.core.ApplicationGenerator;
import org.kie.kogito.codegen.core.utils.ApplicationGeneratorDiscovery;
import org.kie.kogito.codegen.manager.processes.PersistenceGenerationHelper;
-import org.kie.kogito.codegen.manager.util.CodeGenManagerUtil;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import static org.drools.codegen.common.GeneratedFileType.COMPILED_CLASS;
import static
org.kie.efesto.common.api.constants.Constants.INDEXFILE_DIRECTORY_PROPERTY;
@@ -41,14 +37,11 @@ import static
org.kie.kogito.codegen.manager.CompilerHelper.SOURCES;
public class GenerateModelHelper {
- private static final Logger LOGGER =
LoggerFactory.getLogger(GenerateModelHelper.class);
-
private GenerateModelHelper() {
}
public record GenerateModelInfo(ClassLoader projectClassLoader,
KogitoBuildContext kogitoBuildContext,
- boolean onDemand,
boolean generatePartial,
Map<String, String> properties,
File outputDirectory,
@@ -60,7 +53,7 @@ public class GenerateModelHelper {
boolean keepSources) {
public GenerateModelInfo(ClassLoader projectClassLoader,
KogitoBuildContext kogitoBuildContext, BuilderManager.BuildInfo buildInfo) {
- this(projectClassLoader, kogitoBuildContext, buildInfo.onDemand(),
buildInfo.generatePartial(), buildInfo.properties(),
+ this(projectClassLoader, kogitoBuildContext,
buildInfo.generatePartial(), buildInfo.properties(),
buildInfo.outputDirectory().toFile(),
buildInfo.runtimeClassPathElements(),
buildInfo.projectBaseAbsolutePath().toFile(),
@@ -81,13 +74,6 @@ public class GenerateModelHelper {
}
public static void generateModel(GenerateModelInfo generateModelInfo) {
- Map<String, Collection<GeneratedFile>> generatedModelFiles;
- if (generateModelInfo.onDemand) {
- LOGGER.info("On-Demand Mode is On. Use mvn compile
kogito:scaffold");
- generatedModelFiles = new HashMap<>();
- } else {
- generatedModelFiles = generateModelFiles(new
GenerateModelFilesInfo(generateModelInfo));
- }
if (generateModelInfo.outputDirectory == null) {
throw new IllegalStateException("outputDirectory is null");
}
@@ -96,24 +82,41 @@ public class GenerateModelHelper {
System.clearProperty(INDEXFILE_DIRECTORY_PROPERTY);
}
+ /* 1. Execute Code Generation based on KIE models */
+ Map<String, Collection<GeneratedFile>> generatedModelFiles =
generateModelFiles(new GenerateModelFilesInfo(generateModelInfo));
+
CompilerHelper.CompileInfo compileInfo =
new
CompilerHelper.CompileInfo(generatedModelFiles.get(SOURCES),
generatedModelFiles.get(RESOURCES), generateModelInfo);
- // Compile and write model files
+ /* 2. Persist the models' code-generated source and resources files in
target (maven) or gradle (build) */
+
GeneratedFileManager.dumpGeneratedFiles(compileInfo.generatedSources(),
compileInfo.baseDir().toPath());
+ GeneratedFileManager.dumpGeneratedFiles(compileInfo.resources(),
compileInfo.baseDir().toPath());
+
+ /* 3. Compile and persist compiled files in target (maven) or gradle
(build) */
CompilerHelper.compileAndDump(compileInfo);
+ /*
+ * 4. Execute Code Generation based on process extensions modules.
+ * This MUST be executed AFTER models' code-generated sources are
compiled
+ * The code generated in this phase DEPENDS on the code previously
generated.
+ */
Map<String, Collection<GeneratedFile>> generatedPersistenceFiles =
PersistenceGenerationHelper.generatePersistenceFiles(generateModelInfo.kogitoBuildContext,
generateModelInfo.projectClassLoader, generateModelInfo.schemaVersion);
- // Compile and write persistence files
compileInfo =
new
CompilerHelper.CompileInfo(generatedPersistenceFiles.get(SOURCES),
generatedPersistenceFiles.get(RESOURCES),
generateModelInfo);
+
+ /* 5. Persist the process extension code-generated source and
resources files in target (maven) or gradle (build) */
+
GeneratedFileManager.dumpGeneratedFiles(generatedPersistenceFiles.get(SOURCES),
compileInfo.baseDir().toPath());
+
GeneratedFileManager.dumpGeneratedFiles(generatedPersistenceFiles.get(RESOURCES),
compileInfo.baseDir().toPath());
+
+ /* 6. Compile and persist compiled files in target (maven) or gradle
(build) */
CompilerHelper.compileAndDump(compileInfo);
if (!generateModelInfo.keepSources()) {
-
CodeGenManagerUtil.deleteDrlFiles(generateModelInfo.outputDirectory().toPath());
+
GeneratedFileManager.deleteFilesByExtension(generateModelInfo.outputDirectory().toPath(),
"drl");
}
}
diff --git
a/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/GeneratedFileManager.java
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/GeneratedFileManager.java
new file mode 100644
index 0000000000..f3ef94292f
--- /dev/null
+++
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/GeneratedFileManager.java
@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+package org.kie.kogito.codegen.manager;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import org.drools.codegen.common.GeneratedFile;
+import org.drools.codegen.common.GeneratedFileWriter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Utility class responsible for managing and writing generated files to
specific locations.
+ * This class provides methods to handle the dumping of generated files while
+ * leveraging an internally configured {@code GeneratedFileWriter} instance.
+ * The {@code GeneratedFileManager} is designed to be used as a static utility
and
+ * therefore cannot be instantiated.
+ */
+public class GeneratedFileManager {
+
+ private static final Logger LOGGER =
LoggerFactory.getLogger(GeneratedFileManager.class);
+
+ private static final GeneratedFileWriter.Builder
GENERATED_FILE_WRITER_BUILDER =
+ GeneratedFileWriter.builder("kogito",
"kogito.codegen.resources.directory", "kogito.codegen.sources.directory");
+
+ private GeneratedFileManager() {
+ // Not instantiable - static methods only.
+ }
+
+ /**
+ * Dumps a collection of generated files to the specified base path using
a configured {@code GeneratedFileWriter}.
+ * If the provided collection of generated files is null or empty, no
action is taken.
+ *
+ * @param generatedFiles the collection of {@code GeneratedFile} objects
to be written; may be null or empty.
+ * @param basePath the base directory {@code Path} where the files will be
written; must not be null.
+ * @throws NullPointerException if {@code basePath} is null.
+ */
+ public static void dumpGeneratedFiles(Collection<GeneratedFile>
generatedFiles, Path basePath) {
+ Objects.requireNonNull(basePath, "basePath must not be null");
+
+ if (generatedFiles == null || generatedFiles.isEmpty()) {
+ LOGGER.debug("No generated files to write (0 items).");
+ return;
+ }
+
+ GeneratedFileWriter writer =
GENERATED_FILE_WRITER_BUILDER.build(basePath);
+ generatedFiles.forEach(generatedFile ->
writeGeneratedFile(generatedFile, writer));
+ }
+
+ /**
+ * Writes a single {@code GeneratedFile} to its target destination using
the specified {@code GeneratedFileWriter}.
+ * The method logs the file path if logging at the INFO level is enabled.
+ *
+ * @param generatedFile the {@code GeneratedFile} to be written; must not
be null
+ * @param writer the {@code GeneratedFileWriter} responsible for handling
the file write operation; must not be null
+ */
+ static void writeGeneratedFile(GeneratedFile generatedFile,
GeneratedFileWriter writer) {
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info("Writing file: {}", generatedFile.path());
+ }
+ writer.write(generatedFile);
+ }
+
+ /**
+ * Deletes all files with the specified extension in a given directory
+ *
+ * @param directory the directory to search for files
+ * @param extension the file extension to match (e.g., "drl", "dmn",
"java")
+ */
+ public static void deleteFilesByExtension(Path directory, String
extension) {
+ Objects.requireNonNull(directory, "directory must not be null");
+ Objects.requireNonNull(extension, "extension must not be null");
+
+ if (extension.isBlank()) {
+ throw new IllegalArgumentException("extension must not be blank");
+ }
+
+ if (!Files.exists(directory)) {
+ throw new IllegalArgumentException("directory does not exist: " +
directory);
+ }
+
+ if (!Files.isDirectory(directory)) {
+ throw new IllegalArgumentException("path is not a directory: " +
directory);
+ }
+
+ final String normalizedExtension = extension.startsWith(".") ?
extension : "." + extension;
+
+ LOGGER.debug("Deleting files with extension '{}' in directory: {}",
normalizedExtension, directory);
+
+ try (final Stream<Path> files = Files.find(directory,
+ Integer.MAX_VALUE,
+ (path, attributes) -> attributes.isRegularFile() &&
+
path.getFileName().toString().toLowerCase().endsWith(normalizedExtension.toLowerCase())))
{
+ files.forEach(path -> {
+ try {
+ Files.delete(path);
+ LOGGER.debug("Deleted file: {}", path);
+ } catch (IOException e) {
+ throw new UncheckedIOException("Failed to delete: " +
path, e);
+ }
+ });
+ } catch (IOException e) {
+ throw new UncheckedIOException(
+ "Error during " + normalizedExtension + " files deletion
in: " + directory, e);
+ }
+ }
+
+}
diff --git
a/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/util/CodeGenManagerUtil.java
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/util/CodeGenManagerUtil.java
index 05addb853b..79160aa6f8 100644
---
a/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/util/CodeGenManagerUtil.java
+++
b/kogito-codegen-modules/kogito-codegen-manager/src/main/java/org/kie/kogito/codegen/manager/util/CodeGenManagerUtil.java
@@ -18,22 +18,16 @@
*/
package org.kie.kogito.codegen.manager.util;
-import java.io.IOException;
-import java.io.UncheckedIOException;
import java.lang.reflect.Modifier;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
-import java.nio.file.FileSystems;
-import java.nio.file.Files;
import java.nio.file.Path;
-import java.nio.file.PathMatcher;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
-import java.util.stream.Stream;
import org.drools.codegen.common.AppPaths;
import org.drools.codegen.common.DroolsModelBuildContext;
@@ -57,7 +51,6 @@ import org.slf4j.LoggerFactory;
public class CodeGenManagerUtil {
private static final Logger LOGGER =
LoggerFactory.getLogger(CodeGenManagerUtil.class);
- public static final PathMatcher DRL_FILE_MATCHER =
FileSystems.getDefault().getPathMatcher("glob:**.drl");
public enum Framework {
QUARKUS("quarkus"),
@@ -206,23 +199,4 @@ public class CodeGenManagerUtil {
return false;
}
}
-
- /**
- * It deletes all DRL files in a given Path directory
- */
- public static void deleteDrlFiles(Path directory) {
- try (final Stream<Path> drlFiles = Files.find(directory,
- Integer.MAX_VALUE,
- (p, f) -> DRL_FILE_MATCHER.matches(p))) {
- drlFiles.forEach(p -> {
- try {
- Files.delete(p);
- } catch (IOException e) {
- throw new UncheckedIOException(e);
- }
- });
- } catch (IOException e) {
- throw new UncheckedIOException("Error during .drl files deletion",
e);
- }
- }
}
diff --git
a/kogito-codegen-modules/kogito-codegen-manager/src/test/java/org/kie/kogito/codegen/manager/GeneratedFileManagerTest.java
b/kogito-codegen-modules/kogito-codegen-manager/src/test/java/org/kie/kogito/codegen/manager/GeneratedFileManagerTest.java
new file mode 100644
index 0000000000..3661b12e93
--- /dev/null
+++
b/kogito-codegen-modules/kogito-codegen-manager/src/test/java/org/kie/kogito/codegen/manager/GeneratedFileManagerTest.java
@@ -0,0 +1,337 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.kie.kogito.codegen.manager;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.drools.codegen.common.GeneratedFile;
+import org.drools.codegen.common.GeneratedFileType;
+import org.drools.codegen.common.GeneratedFileWriter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.ArgumentCaptor;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+class GeneratedFileManagerTest {
+
+ @TempDir
+ Path tempDir;
+
+ private Path testDirectory;
+
+ @BeforeEach
+ void setUp() throws IOException {
+ testDirectory = tempDir.resolve("test-dir");
+ Files.createDirectories(testDirectory);
+ }
+
+ @AfterEach
+ void tearDown() throws IOException {
+ if (Files.exists(testDirectory)) {
+ Files.walk(testDirectory)
+ .sorted(Comparator.reverseOrder())
+ .forEach(path -> {
+ try {
+ Files.deleteIfExists(path);
+ } catch (IOException e) {
+ // Ignore cleanup errors
+ }
+ });
+ }
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideFileTypeTestCases")
+ void dumpGeneratedFiles_withDifferentFileTypes_shouldWriteAllTypes(
+ List<String> fileNames, List<String> expectedFiles) throws
IOException {
+ List<GeneratedFile> generatedFiles = new ArrayList<>();
+ for (String fileName : fileNames) {
+ generatedFiles.add(createMockGeneratedFile(fileName));
+ }
+
+ GeneratedFileManager.dumpGeneratedFiles(generatedFiles, testDirectory);
+
+ assertThat(testDirectory).exists();
+
+ // Verify the correct number of files were created
+ try (Stream<Path> files = Files.walk(testDirectory)) {
+ long fileCount = files.filter(Files::isRegularFile).count();
+ assertThat(fileCount).isEqualTo(expectedFiles.size());
+ }
+
+ // Verify each expected file exists somewhere in the directory tree
+ try (Stream<Path> files = Files.walk(testDirectory)) {
+ List<String> actualFileNames = files
+ .filter(Files::isRegularFile)
+ .map(Path::getFileName)
+ .map(Path::toString)
+ .sorted()
+ .toList();
+
+ List<String> sortedExpectedFiles = new ArrayList<>(expectedFiles);
+ sortedExpectedFiles.sort(String::compareTo);
+
+ assertThat(actualFileNames)
+ .as("All expected files should be written")
+ .containsExactlyElementsOf(sortedExpectedFiles);
+ }
+
+ // Verify file content for the first file
+ if (!expectedFiles.isEmpty()) {
+ try (Stream<Path> files = Files.walk(testDirectory)) {
+ Path firstFile = files
+ .filter(Files::isRegularFile)
+ .filter(p ->
p.getFileName().toString().equals(expectedFiles.get(0)))
+ .findFirst()
+ .orElseThrow();
+
+ String content = Files.readString(firstFile);
+ assertThat(content).isEqualTo("// Generated content");
+ }
+ }
+ }
+
+ @Test
+ void dumpGeneratedFiles_withNullBasePath_shouldThrowNullPointerException()
{
+ Collection<GeneratedFile> generatedFiles = createMockGeneratedFiles(1);
+
+ assertThatThrownBy(() ->
GeneratedFileManager.dumpGeneratedFiles(generatedFiles, null))
+ .isInstanceOf(NullPointerException.class)
+ .hasMessageContaining("basePath must not be null");
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void
dumpGeneratedFiles_withNullOrEmptyCollection_shouldNotWriteFiles(Collection<GeneratedFile>
generatedFiles) {
+ GeneratedFileManager.dumpGeneratedFiles(generatedFiles, testDirectory);
+
+ // no exception should be thrown and directory should still exist
+ assertThat(testDirectory).exists();
+ }
+
+ @Test
+ void writeGeneratedFile_withValidFile_shouldCallWriter() {
+ GeneratedFile generatedFile = createMockGeneratedFile("TestFile.java");
+ GeneratedFileWriter writer = mock(GeneratedFileWriter.class);
+
+ GeneratedFileManager.writeGeneratedFile(generatedFile, writer);
+
+ ArgumentCaptor<GeneratedFile> captor =
ArgumentCaptor.forClass(GeneratedFile.class);
+ verify(writer, times(1)).write(captor.capture());
+ assertThat(captor.getValue()).isEqualTo(generatedFile);
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideExtensionTestCases")
+ void
deleteFilesByExtension_withVariousExtensions_shouldDeleteMatchingFiles(
+ String extension, List<String> filesToCreate, List<String>
expectedDeleted) throws IOException {
+
+ for (String fileName : filesToCreate) {
+ Path file = testDirectory.resolve(fileName);
+ Files.createDirectories(file.getParent());
+ Files.createFile(file);
+ }
+
+ GeneratedFileManager.deleteFilesByExtension(testDirectory, extension);
+
+ for (String fileName : filesToCreate) {
+ Path file = testDirectory.resolve(fileName);
+ if (expectedDeleted.contains(fileName)) {
+ assertThat(file).doesNotExist();
+ } else {
+ assertThat(file).exists();
+ }
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = { ".java", "java", ".JAVA", "JAVA" })
+ void
deleteFilesByExtension_withDifferentExtensionFormats_shouldNormalizeAndDelete(String
extension) throws IOException {
+ Path javaFile = testDirectory.resolve("Test.java");
+ Path txtFile = testDirectory.resolve("Test.txt");
+ Files.createFile(javaFile);
+ Files.createFile(txtFile);
+
+ GeneratedFileManager.deleteFilesByExtension(testDirectory, extension);
+
+ assertThat(javaFile).doesNotExist();
+ assertThat(txtFile).exists();
+ }
+
+ @Test
+ void
deleteFilesByExtension_withNestedDirectories_shouldDeleteRecursively() throws
IOException {
+ Path subDir = testDirectory.resolve("subdir");
+ Files.createDirectories(subDir);
+ Path file1 = testDirectory.resolve("file1.drl");
+ Path file2 = subDir.resolve("file2.drl");
+ Path file3 = subDir.resolve("file3.txt");
+ Files.createFile(file1);
+ Files.createFile(file2);
+ Files.createFile(file3);
+
+ GeneratedFileManager.deleteFilesByExtension(testDirectory, ".drl");
+
+ assertThat(file1).doesNotExist();
+ assertThat(file2).doesNotExist();
+ assertThat(file3).exists();
+ }
+
+ @Test
+ void
deleteFilesByExtension_withNonExistentDirectory_shouldThrowIllegalArgumentException()
{
+ Path nonExistentDir = tempDir.resolve("non-existent");
+
+ assertThatThrownBy(() ->
GeneratedFileManager.deleteFilesByExtension(nonExistentDir, ".java"))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("directory does not exist");
+ }
+
+ @Test
+ void deleteFilesByExtension_withEmptyDirectory_shouldNotThrowException()
throws IOException {
+ Path emptyDir = testDirectory.resolve("empty");
+ Files.createDirectories(emptyDir);
+
+ GeneratedFileManager.deleteFilesByExtension(emptyDir, ".java");
+ assertThat(emptyDir).exists();
+ }
+
+ @Test
+ void deleteFilesByExtension_withNoMatchingFiles_shouldNotDeleteAnything()
throws IOException {
+ Path file1 = testDirectory.resolve("file1.txt");
+ Path file2 = testDirectory.resolve("file2.xml");
+ Files.createFile(file1);
+ Files.createFile(file2);
+
+ GeneratedFileManager.deleteFilesByExtension(testDirectory, ".java");
+
+ assertThat(file1).exists();
+ assertThat(file2).exists();
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = { "", " " })
+ void
deleteFilesByExtension_withEmptyOrBlankExtension_shouldThrowIllegalArgumentException(String
extension) {
+ assertThatThrownBy(() ->
GeneratedFileManager.deleteFilesByExtension(testDirectory, extension))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("extension must not be blank");
+ }
+
+ @Test
+ void
deleteFilesByExtension_withNullDirectory_shouldThrowNullPointerException() {
+ assertThatThrownBy(() ->
GeneratedFileManager.deleteFilesByExtension(null, ".java"))
+ .isInstanceOf(NullPointerException.class)
+ .hasMessageContaining("directory must not be null");
+ }
+
+ @Test
+ void
deleteFilesByExtension_withNullExtension_shouldThrowNullPointerException() {
+ assertThatThrownBy(() ->
GeneratedFileManager.deleteFilesByExtension(testDirectory, null))
+ .isInstanceOf(NullPointerException.class)
+ .hasMessageContaining("extension must not be null");
+ }
+
+ @Test
+ void
deleteFilesByExtension_withFileInsteadOfDirectory_shouldThrowIllegalArgumentException()
throws IOException {
+ Path file = testDirectory.resolve("not-a-directory.txt");
+ Files.createFile(file);
+
+ assertThatThrownBy(() ->
GeneratedFileManager.deleteFilesByExtension(file, ".java"))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("path is not a directory");
+ }
+
+ // Helper methods
+
+ private Collection<GeneratedFile> createMockGeneratedFiles(int count) {
+ List<GeneratedFile> files = new ArrayList<>();
+ for (int i = 0; i < count; i++) {
+ files.add(createMockGeneratedFile("File" + i + ".java"));
+ }
+ return files;
+ }
+
+ private GeneratedFile createMockGeneratedFile(String path) {
+ return new GeneratedFile(
+ GeneratedFileType.SOURCE,
+ path,
+ "// Generated content".getBytes());
+ }
+
+ private static Stream<Arguments> provideFileTypeTestCases() {
+ return Stream.of(
+ // Test case: files to create, expected files
+ Arguments.of(
+ List.of("Test.java", "Main.java", "Config.json"),
+ List.of("Test.java", "Main.java", "Config.json")),
+ Arguments.of(
+ List.of("Model.class", "Service.class"),
+ List.of("Model.class", "Service.class")),
+ Arguments.of(
+ List.of("schema.proto", "message.proto"),
+ List.of("schema.proto", "message.proto")),
+ Arguments.of(
+ List.of("data.json", "config.xml", "rules.drl"),
+ List.of("data.json", "config.xml", "rules.drl")),
+ Arguments.of(
+ List.of("app.properties", "settings.yaml",
"metadata.txt"),
+ List.of("app.properties", "settings.yaml",
"metadata.txt")),
+ Arguments.of(
+ List.of("mixed.java", "data.json", "schema.proto",
"binary.class"),
+ List.of("mixed.java", "data.json", "schema.proto",
"binary.class")));
+ }
+
+ private static Stream<Arguments> provideExtensionTestCases() {
+ return Stream.of(
+ // Test case: extension, files to create, files expected to be
deleted
+ Arguments.of(
+ ".java",
+ List.of("Test.java", "Main.java", "Config.xml"),
+ List.of("Test.java", "Main.java")),
+ Arguments.of(
+ ".drl",
+ List.of("rules.drl", "test.DRL", "other.txt"),
+ List.of("rules.drl", "test.DRL")),
+ Arguments.of(
+ "dmn",
+ List.of("decision.dmn", "process.bpmn", "model.DMN"),
+ List.of("decision.dmn", "model.DMN")),
+ Arguments.of(
+ ".txt",
+ List.of("readme.txt", "notes.TXT", "data.json"),
+ List.of("readme.txt", "notes.TXT")));
+ }
+}
diff --git
a/kogito-codegen-modules/kogito-codegen-manager/src/test/resources/logback-test.xml
b/kogito-codegen-modules/kogito-codegen-manager/src/test/resources/logback-test.xml
new file mode 100644
index 0000000000..6c11807ba3
--- /dev/null
+++
b/kogito-codegen-modules/kogito-codegen-manager/src/test/resources/logback-test.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+
+-->
+<configuration>
+ <appender name="consoleAppender"
class="ch.qos.logback.core.ConsoleAppender">
+ <encoder>
+ <!-- %l lowers performance -->
+ <!--<pattern>%d [%t] %-5p %l%n %m%n</pattern>-->
+ <pattern>%d [%t] %-5p %m%n</pattern>
+ </encoder>
+ </appender>
+
+ <!-- Suppress most logs during tests - only show ERROR level -->
+ <root level="ERROR">
+ <appender-ref ref="consoleAppender" />
+ </root>
+
+ <!-- Keep Kogito package at WARN to see important warnings -->
+ <logger name="org.kie.kogito" level="WARN" additivity="false">
+ <appender-ref ref="consoleAppender" />
+ </logger>
+</configuration>
\ No newline at end of file
diff --git a/kogito-maven-plugin-test/pom.xml b/kogito-maven-plugin-test/pom.xml
index 5daacf49f2..d77ce8630e 100644
--- a/kogito-maven-plugin-test/pom.xml
+++ b/kogito-maven-plugin-test/pom.xml
@@ -149,7 +149,6 @@
<version>${project.version}</version>
<executions>
<execution>
- <phase>compile</phase>
<goals>
<goal>generateModel</goal>
</goals>
diff --git a/kogito-maven-plugin/README.md b/kogito-maven-plugin/README.md
index bae92dfa2a..846aee3b67 100644
--- a/kogito-maven-plugin/README.md
+++ b/kogito-maven-plugin/README.md
@@ -45,7 +45,6 @@ In your Kogito project root `pom.xml` file, add the following
plugin declaration
<version>${version.org.kie.kogito}</version>
<executions>
<execution>
- <phase>compile</phase>
<goals>
<goal>generateModel</goal>
</goals>
diff --git a/kogito-maven-plugin/pom.xml b/kogito-maven-plugin/pom.xml
index face522094..2db77cc9fc 100644
--- a/kogito-maven-plugin/pom.xml
+++ b/kogito-maven-plugin/pom.xml
@@ -35,6 +35,7 @@
<packaging>maven-plugin</packaging>
<name>Kogito :: Maven Plugin</name>
+ <description>Maven plugin for Kogito code generation from DMN, BPMN, DRL,
and PMML assets</description>
<properties>
<java.module.name>org.kie.kogito.maven.plugin</java.module.name>
diff --git
a/kogito-maven-plugin/src/main/java/org/kie/kogito/maven/plugin/AbstractKieMojo.java
b/kogito-maven-plugin/src/main/java/org/kie/kogito/maven/plugin/AbstractKieMojo.java
index 92aff14dd5..ad31a9b885 100644
---
a/kogito-maven-plugin/src/main/java/org/kie/kogito/maven/plugin/AbstractKieMojo.java
+++
b/kogito-maven-plugin/src/main/java/org/kie/kogito/maven/plugin/AbstractKieMojo.java
@@ -75,12 +75,9 @@ public abstract class AbstractKieMojo extends AbstractMojo {
@Parameter(required = true, defaultValue =
"${project.build.sourceEncoding}")
protected String projectSourceEncoding;
- @Parameter(property = "kogito.jsonSchema.version", required = false)
//TODO double check this required false
+ @Parameter(property = "kogito.jsonSchema.version")
protected String jsonSchemaVersion;
- @Parameter(property = "kogito.codegen.ondemand", defaultValue = "false")
- protected boolean onDemand;
-
@Parameter(property = "kogito.sources.keep", defaultValue = "false")
protected boolean keepSources;
@@ -91,11 +88,10 @@ public abstract class AbstractKieMojo extends AbstractMojo {
protected MavenProject mavenProject;
public void buildProject() throws MojoExecutionException {
- getLog().info("buildProject");
- executionLog();
try {
Set<URI> projectFilesUris = MojoUtil.getProjectFiles(mavenProject,
null);
- BuilderManager.BuildInfo buildInfo = new
BuilderManager.BuildInfo(projectFilesUris,
+ BuilderManager.BuildInfo buildInfo = new BuilderManager.BuildInfo(
+ projectFilesUris,
projectBaseDir.toPath(),
projectBuildOutputDirectory.toPath(),
mavenProject.getGroupId(),
@@ -106,7 +102,6 @@ public abstract class AbstractKieMojo extends AbstractMojo {
jsonSchemaVersion,
generatePartial,
persistence,
- onDemand,
keepSources,
mavenProject.getRuntimeClasspathElements(),
discoverFramework(),
@@ -117,16 +112,6 @@ public abstract class AbstractKieMojo extends AbstractMojo
{
}
}
- protected void executionLog() {
- getLog().info("Compiler Java Version: " + mavenCompilerJavaVersion);
- getLog().info("Compiler Source Encoding: " + projectSourceEncoding);
- getLog().info("Project base directory: " +
projectBaseDir.getAbsolutePath());
- getLog().info("Build output directory: " +
projectBuildOutputDirectory);
- getLog().info("Partial generation is enabled: " + generatePartial);
- getLog().info("Json schema version: " + jsonSchemaVersion);
- getLog().info("===================================");
- }
-
CodeGenManagerUtil.Framework discoverFramework() {
if (MojoUtil.hasDependency(mavenProject,
CodeGenManagerUtil.Framework.QUARKUS)) {
return CodeGenManagerUtil.Framework.QUARKUS;
diff --git
a/kogito-maven-plugin/src/main/java/org/kie/kogito/maven/plugin/GenerateModelMojo.java
b/kogito-maven-plugin/src/main/java/org/kie/kogito/maven/plugin/GenerateModelMojo.java
index 9cf101dd55..cfadc8c08b 100644
---
a/kogito-maven-plugin/src/main/java/org/kie/kogito/maven/plugin/GenerateModelMojo.java
+++
b/kogito-maven-plugin/src/main/java/org/kie/kogito/maven/plugin/GenerateModelMojo.java
@@ -25,15 +25,33 @@ import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.ResolutionScope;
+/**
+ * Maven Mojo for generating Kogito model code from various asset types.
+ * <p>
+ * This goal generates Java code from Kogito assets including:
+ * <ul>
+ * <li>Business Process Models (BPMN)</li>
+ * <li>Decision Models (DMN)</li>
+ * <li>Business Rules (DRL)</li>
+ * <li>Predictive Models (PMML)</li>
+ * </ul>
+ * <p>
+ * The generated code includes process implementations, decision services,
rule units,
+ * and prediction models that are required for runtime execution of Kogito
applications.
+ * <p>
+ * This mojo is bound to the {@code process-classes} phase. This is required
to ensure that
+ * the project's static classes written by the end user in the src directory
are compiled
+ * prior to code generation.
+ *
+ */
@Mojo(name = "generateModel",
requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME,
- defaultPhase = LifecyclePhase.COMPILE,
+ defaultPhase = LifecyclePhase.PROCESS_CLASSES,
threadSafe = true)
public class GenerateModelMojo extends AbstractKieMojo {
@Override
public void execute() throws MojoExecutionException {
- getLog().info("execute");
buildProject();
}
}
diff --git
a/kogito-maven-plugin/src/test/java/org/kie/kogito/maven/plugin/GenerateModelMojoTest.java
b/kogito-maven-plugin/src/test/java/org/kie/kogito/maven/plugin/GenerateModelMojoTest.java
index cd56c4ea81..3167f8e56c 100644
---
a/kogito-maven-plugin/src/test/java/org/kie/kogito/maven/plugin/GenerateModelMojoTest.java
+++
b/kogito-maven-plugin/src/test/java/org/kie/kogito/maven/plugin/GenerateModelMojoTest.java
@@ -30,12 +30,10 @@ import org.kie.kogito.codegen.manager.GenerateModelHelper;
import org.kie.kogito.codegen.manager.processes.PersistenceGenerationHelper;
import org.kie.kogito.codegen.manager.util.CodeGenManagerUtil;
import org.mockito.MockedStatic;
-import org.mockito.verification.VerificationMode;
import static org.assertj.core.api.Fail.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mockStatic;
-import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
@MojoTest
@@ -43,15 +41,8 @@ class GenerateModelMojoTest {
@Test
@InjectMojo(goal = "generateModel", pom =
"src/test/resources/unit/generate-model/pom.xml")
- void generateModelWithOnDemand(GenerateModelMojo mojo) {
- commonSetup(mojo, true);
- commonGenerateModel(mojo);
- }
-
- @Test
- @InjectMojo(goal = "generateModel", pom =
"src/test/resources/unit/generate-model/pom.xml")
- void generateModelWithoutOnDemand(GenerateModelMojo mojo) {
- commonSetup(mojo, false);
+ void generateModel(GenerateModelMojo mojo) {
+ commonSetup(mojo);
commonGenerateModel(mojo);
}
@@ -67,8 +58,7 @@ class GenerateModelMojoTest {
builderManagerMockedStatic.verify(() ->
BuilderManager.build(any(BuilderManager.BuildInfo.class)), times(1));
codeGenManagerUtilMockedStatic.verify(() ->
CodeGenManagerUtil.setSystemProperties(any()), times(1));
generateModelHelperMockedStatic.verify(() ->
GenerateModelHelper.generateModel(any(GenerateModelHelper.GenerateModelInfo.class)),
times(1));
- VerificationMode expectedGeneratedModelFiles = mojo.onDemand ?
never() : times(1);
- generateModelHelperMockedStatic.verify(() ->
GenerateModelHelper.generateModelFiles(any(GenerateModelHelper.GenerateModelFilesInfo.class)),
expectedGeneratedModelFiles);
+ generateModelHelperMockedStatic.verify(() ->
GenerateModelHelper.generateModelFiles(any(GenerateModelHelper.GenerateModelFilesInfo.class)),
times(1));
compilerHelperMockedStatic.verify(() ->
CompilerHelper.compileAndDump(any(CompilerHelper.CompileInfo.class)), times(2));
persistenceGenerationHelperMockedStatic.verify(() ->
PersistenceGenerationHelper.generatePersistenceFiles(any(),
any(),
@@ -78,10 +68,9 @@ class GenerateModelMojoTest {
}
}
- private void commonSetup(GenerateModelMojo mojo, boolean onDemand) {
+ private void commonSetup(GenerateModelMojo mojo) {
mojo.projectBuildOutputDirectory = new
File(mojo.project.getModel().getBuild().getOutputDirectory());
mojo.projectBaseDir = mojo.project.getBasedir();
mojo.projectSourceEncoding = "UTF-8";
- mojo.onDemand = onDemand;
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
