Examples with KogitoBuildContext org.kie.kogito.codegen.api.context.KogitoBuildContext used on opensource projects

Example 21 with KogitoBuildContext

use of org.kie.kogito.codegen.api.context.KogitoBuildContext in project kogito-runtimes by kiegroup.

the class PathResolverTest method verifyClasspathResolver.

@ParameterizedTest
@MethodSource("org.kie.kogito.codegen.api.utils.KogitoContextTestUtils#contextBuilders")
void verifyClasspathResolver(final KogitoBuildContext.Builder contextBuilder) {
    final String[] resources = new String[] { "specs/__files/petstore.json", "classpath://specs/__files/petstore.json" };
    final KogitoBuildContext context = contextBuilder.build();
    for (String resource : resources) {
        final OpenApiSpecDescriptor openApiSpecDescriptor = new OpenApiSpecDescriptor(resource);
        final PathResolver resolver = PathResolverFactory.newResolver(openApiSpecDescriptor, context);
        assertThat(resolver).isInstanceOf(ClasspathResolver.class);
        final String path = resolver.resolve(openApiSpecDescriptor);
        this.assertResolverPath(path);
    }
}

Example 22 with KogitoBuildContext

use of org.kie.kogito.codegen.api.context.KogitoBuildContext in project kogito-runtimes by kiegroup.

the class DecisionValidationTest method codeGenerator.

private DecisionCodegen codeGenerator(String path, Consumer<Properties> codeGenContextProperties) throws Exception {
    Properties props = new Properties();
    codeGenContextProperties.accept(props);
    KogitoBuildContext context = JavaKogitoBuildContext.builder().withApplicationProperties(props).build();
    return DecisionCodegen.ofPath(context, Paths.get(path).toAbsolutePath());
}

Example 23 with KogitoBuildContext

use of org.kie.kogito.codegen.api.context.KogitoBuildContext in project kogito-runtimes by kiegroup.

the class ProcessCloudEventMetaFactoryGeneratorTest method generateAndParseClass.

private ClassOrInterfaceDeclaration generateAndParseClass(String bpmnFile, int expectedTriggers, boolean withInjection) {
    KogitoBuildContext context = getContext(withInjection);
    List<ProcessExecutableModelGenerator> execModelGenerators = ProcessGenerationUtils.execModelFromProcessFile(bpmnFile);
    final ProcessCloudEventMetaFactoryGenerator generator = new ProcessCloudEventMetaFactoryGenerator(context, execModelGenerators);
    Collection<ProcessCloudEventMeta> ces = generator.getCloudEventMetaBuilder().build(execModelGenerators);
    if (expectedTriggers > 0) {
        assertThat(ces).isNotEmpty();
        assertThat(ces.size()).isEqualTo(expectedTriggers);
    } else {
        assertThat(ces).isEmpty();
    }
    final String source = generator.generate();
    assertThat(source).isNotNull();
    final ClassOrInterfaceDeclaration clazz = StaticJavaParser.parse(source).getClassByName(generator.getClassName()).orElseThrow(() -> new IllegalArgumentException("Class does not exists"));
    return clazz;
}

Example 24 with KogitoBuildContext

use of org.kie.kogito.codegen.api.context.KogitoBuildContext in project kogito-runtimes by kiegroup.

the class MongoDBPersistenceGeneratorTest method test.

@ParameterizedTest
@MethodSource("persistenceTestContexts")
void test(KogitoBuildContext context) {
    context.setApplicationProperty(KOGITO_PERSISTENCE_TYPE, persistenceType());
    ReflectionProtoGenerator protoGenerator = ReflectionProtoGenerator.builder().build(Collections.singleton(GeneratedPOJO.class));
    PersistenceGenerator persistenceGenerator = new PersistenceGenerator(context, protoGenerator, new ReflectionMarshallerGenerator(context));
    Collection<GeneratedFile> generatedFiles = persistenceGenerator.generate();
    if (context.hasDI()) {
        Optional<GeneratedFile> generatedCLASSFile = generatedFiles.stream().filter(gf -> gf.category() == GeneratedFileType.SOURCE.category()).filter(f -> PERSISTENCE_FILE_PATH.equals(f.relativePath())).findAny();
        assertTrue(generatedCLASSFile.isPresent());
        GeneratedFile classFile = generatedCLASSFile.get();
        assertEquals(PERSISTENCE_FILE_PATH, classFile.relativePath());
        final CompilationUnit compilationUnit = parse(new ByteArrayInputStream(classFile.contents()));
        final ClassOrInterfaceDeclaration classDeclaration = compilationUnit.findFirst(ClassOrInterfaceDeclaration.class).orElseThrow(() -> new NoSuchElementException("Compilation unit doesn't contain a class or interface declaration!"));
        assertNotNull(classDeclaration);
        final MethodDeclaration methodDeclaration = classDeclaration.findFirst(MethodDeclaration.class, d -> d.getName().getIdentifier().equals("dbName")).orElseThrow(() -> new NoSuchElementException("Class declaration doesn't contain a method named \"dbName\"!"));
        assertNotNull(methodDeclaration);
        assertTrue(methodDeclaration.getBody().isPresent());
        final BlockStmt body = methodDeclaration.getBody().get();
        assertThat(body.getStatements().size()).isOne();
        assertTrue(body.getStatements().get(0).isReturnStmt());
        final ReturnStmt returnStmt = (ReturnStmt) body.getStatements().get(0);
        assertThat(returnStmt.toString()).contains("kogito");
        final MethodDeclaration transactionMethodDeclaration = classDeclaration.findFirst(MethodDeclaration.class, d -> "transactionManager".equals(d.getName().getIdentifier())).orElseThrow(() -> new NoSuchElementException("Class declaration doesn't contain a method named \"transactionManager\"!"));
        assertNotNull(transactionMethodDeclaration);
        assertTrue(transactionMethodDeclaration.getBody().isPresent());
        final BlockStmt transactionMethodBody = transactionMethodDeclaration.getBody().get();
        assertThat(transactionMethodBody.getStatements().size()).isOne();
        assertTrue(transactionMethodBody.getStatements().get(0).isReturnStmt());
        final ReturnStmt transactionReturnStmt = (ReturnStmt) transactionMethodBody.getStatements().get(0);
        assertThat(transactionReturnStmt.toString()).contains("transactionManager");
        Optional<GeneratedFile> generatedTransactionCLASSFile = generatedFiles.stream().filter(gf -> gf.category() == GeneratedFileType.SOURCE.category()).filter(f -> TRANSACTION_FILE_PATH.equals(f.relativePath())).findAny();
        assertTrue(generatedTransactionCLASSFile.isPresent());
        final CompilationUnit transactionCompilationUnit = parse(new ByteArrayInputStream(generatedTransactionCLASSFile.get().contents()));
        final ClassOrInterfaceDeclaration transactionClassDeclaration = transactionCompilationUnit.findFirst(ClassOrInterfaceDeclaration.class).orElseThrow(() -> new NoSuchElementException("Compilation unit doesn't contain a class or interface declaration!"));
        assertNotNull(transactionClassDeclaration);
        final List<ConstructorDeclaration> constructorDeclarations = transactionCompilationUnit.findAll(ConstructorDeclaration.class);
        assertEquals(2, constructorDeclarations.size());
        Optional<ConstructorDeclaration> annotatedConstructorDeclaration = constructorDeclarations.stream().filter(c -> c.isAnnotationPresent(injectionAnnotation(context))).findAny();
        assertTrue(annotatedConstructorDeclaration.isPresent());
        final MethodDeclaration transactionEnabledMethodDeclaration = transactionClassDeclaration.findFirst(MethodDeclaration.class, d -> d.getName().getIdentifier().equals("enabled")).orElseThrow(() -> new NoSuchElementException("Class declaration doesn't contain a method named \"enabled\"!"));
        assertNotNull(transactionEnabledMethodDeclaration);
        assertTrue(transactionEnabledMethodDeclaration.getBody().isPresent());
        final BlockStmt enabledMethodBody = transactionEnabledMethodDeclaration.getBody().get();
        assertThat(enabledMethodBody.getStatements().size()).isOne();
        assertTrue(enabledMethodBody.getStatements().get(0).isReturnStmt());
        final ReturnStmt enabledReturnStmt = (ReturnStmt) enabledMethodBody.getStatements().get(0);
        assertThat(enabledReturnStmt.toString()).contains("enabled");
        final FieldDeclaration transactionEnabledFieldDeclaration = transactionClassDeclaration.findFirst(FieldDeclaration.class, f -> f.getVariable(0).getName().getIdentifier().equals("enabled")).orElseThrow(() -> new NoSuchElementException("Class declaration doesn't contain a field named \"enabled\"!"));
        assertNotNull(transactionEnabledFieldDeclaration);
        final AnnotationExpr transactionEnabledAnnotationDeclaration = transactionEnabledFieldDeclaration.findFirst(AnnotationExpr.class, a -> ((Name) a.getChildNodes().get(0)).getIdentifier().equals(configInjectionAnnotation(context))).orElseThrow(() -> new NoSuchElementException("Field declaration doesn't contain an annotation  named \"" + configInjectionAnnotation(context) + "\"!"));
        assertNotNull(transactionEnabledAnnotationDeclaration);
        assertThat(transactionEnabledAnnotationDeclaration.getChildNodes().get(1).toString()).contains("kogito.persistence.transaction.enabled");
    }
}

Example 25 with KogitoBuildContext

use of org.kie.kogito.codegen.api.context.KogitoBuildContext in project kogito-runtimes by kiegroup.

the class AbstractPersistenceGeneratorTest method persistenceGeneratorSanityCheck.

@ParameterizedTest
@MethodSource("persistenceTestContexts")
void persistenceGeneratorSanityCheck(KogitoBuildContext context) {
    context.setApplicationProperty(KOGITO_PERSISTENCE_TYPE, persistenceType());
    ReflectionProtoGenerator protoGenerator = ReflectionProtoGenerator.builder().build(Collections.singleton(GeneratedPOJO.class));
    PersistenceGenerator persistenceGenerator = new PersistenceGenerator(context, protoGenerator, new ReflectionMarshallerGenerator(context, null));
    Collection<GeneratedFile> generatedFiles = persistenceGenerator.generate();
    int expectedDataIndexProto = hasDataIndexProto(context) ? 2 : 0;
    int expectedListDataIndexProto = hasDataIndexProto(context) ? 1 : 0;
    assertThat(generatedFiles.stream().filter(gf -> gf.type().equals(ProtoGenerator.PROTO_TYPE)).count()).isEqualTo(expectedDataIndexProto);
    assertThat(generatedFiles.stream().filter(gf -> gf.type().equals(ProtoGenerator.PROTO_TYPE) && gf.relativePath().endsWith(".json")).count()).isEqualTo(expectedListDataIndexProto);
    int expectedProtoMarshaller = hasProtoMarshaller(context) ? 10 : 0;
    assertThat(generatedFiles.stream().filter(gf -> gf.type().equals(GeneratedFileType.SOURCE) && gf.relativePath().endsWith("Marshaller.java"))).hasSize(expectedProtoMarshaller);
}