or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

field-analysis.mdgeneral-predicates.mdimport-control.mdindex.mdjava-only-rules.mdmethod-validation.mdsource-predicates.md
tile.json

tessl/maven-org-apache-flink--flink-architecture-tests-base

Base library for Apache Flink architecture tests that provides common ArchUnit extensions and utilities for validating architectural constraints in both production and test code

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.apache.flink/flink-architecture-tests-base@2.1.x

To install, run

npx @tessl/cli install tessl/maven-org-apache-flink--flink-architecture-tests-base@2.1.0

index.mddocs/

Flink Architecture Tests Base

Flink Architecture Tests Base is a foundational Java library that provides common ArchUnit extensions and utilities for writing architectural rules to validate code structure, field properties, and class hierarchies in Apache Flink projects.

Built on top of ArchUnit, this library offers specialized predicates, conditions, and utilities designed specifically for architectural testing in large-scale Java projects, with particular focus on avoiding circular dependencies and maintaining clean architecture.

Package Information

  • Package Name: flink-architecture-tests-base
  • Package Type: Maven
  • Language: Java
  • Group ID: org.apache.flink
  • Artifact ID: flink-architecture-tests-base
  • Version: 2.1.0
  • Installation: Add to your Maven dependencies:
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-architecture-tests-base</artifactId>
    <version>2.1.0</version>
    <scope>test</scope>
</dependency>

Core Imports

import org.apache.flink.architecture.common.Predicates;
import org.apache.flink.architecture.common.JavaFieldPredicates;
import org.apache.flink.architecture.common.Conditions;
import org.apache.flink.architecture.common.GivenJavaClasses;
import org.apache.flink.architecture.common.ImportOptions;
import org.apache.flink.architecture.common.SourcePredicates;

Basic Usage

import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.lang.ArchRule;
import org.apache.flink.architecture.common.GivenJavaClasses;
import org.apache.flink.architecture.common.ImportOptions;
import org.apache.flink.architecture.common.Predicates;

// Import classes with filtering
JavaClasses classes = new ClassFileImporter()
    .withImportOption(new ImportOptions.ExcludeScalaImportOption())
    .withImportOption(new ImportOptions.ExcludeShadedImportOption())
    .importPackages("org.apache.flink");

// Create architecture rules using Java-only class filtering
ArchRule publicConstantsRule = GivenJavaClasses.javaClassesThat()
    .areNotEnums()
    .should()
    .onlyAccessClassesThat(
        Predicates.areDirectlyAnnotatedWithAtLeastOneOf(Component.class)
    );

// Test field properties
ArchRule publicStaticFinalFieldsRule = GivenJavaClasses.javaClassesThat()
    .containAnyFieldsThat(
        Predicates.arePublicStaticFinalOfType("java.lang.String")
    )
    .should()
    .onlyHavePublicStaticFinalFields();

// Validate the rules
publicConstantsRule.check(classes);
publicStaticFinalFieldsRule.check(classes);

Architecture

Flink Architecture Tests Base is organized around several key components:

  • Predicate System: Composable predicates for analyzing classes, fields, and relationships
  • Condition Framework: ArchUnit conditions for validating method signatures and types
  • Import Filtering: Specialized import options for excluding non-Java code and shaded dependencies
  • Type Safety: Strong emphasis on using fully qualified class names to avoid circular dependencies
  • Java Focus: Special handling to work exclusively with Java classes, filtering out Scala code

Capabilities

General Predicates

Core predicates for analyzing Java classes and fields, with support for annotation checking, field property validation, and class hierarchy inspection.

public class Predicates {
    public static DescribedPredicate<JavaClass> areDirectlyAnnotatedWithAtLeastOneOf(
        Class<? extends Annotation>... annotations);
    public static DescribedPredicate<JavaClass> containAnyFieldsInClassHierarchyThat(
        DescribedPredicate<? super JavaField> predicate);
    public static DescribedPredicate<JavaField> arePublicStaticFinalOfType(String fqClassName);
}

General Predicates

Field Analysis

Specialized predicates focused exclusively on JavaField analysis, including modifier checking, type validation, and annotation detection.

public class JavaFieldPredicates {
    public static DescribedPredicate<JavaField> isPublic();
    public static DescribedPredicate<JavaField> isStatic();
    public static DescribedPredicate<JavaField> isFinal();
    public static DescribedPredicate<JavaField> ofType(String fqClassName);
    public static DescribedPredicate<JavaField> annotatedWith(Class<? extends Annotation> annotationType);
}

Field Analysis

Method Validation

ArchUnit conditions for validating method signatures, including deep analysis of parameter types, return types, and exception types.

public class Conditions {
    public static <T extends HasName> ArchCondition<T> fulfill(DescribedPredicate<T> predicate);
    public static ArchCondition<JavaMethod> haveLeafTypes(DescribedPredicate<JavaClass> typePredicate);
    public static ArchCondition<JavaMethod> haveLeafReturnTypes(DescribedPredicate<JavaClass> typePredicate);
}

Method Validation

Import Control

ImportOption implementations for controlling which classes are analyzed during ArchUnit import, with specific support for Maven projects and mixed Java/Scala codebases.

public class ImportOptions {
    public static final class MavenMainClassesOnly implements ImportOption;
    public static final class ExcludeScalaImportOption implements ImportOption;
    public static final class ExcludeShadedImportOption implements ImportOption;
}

Import Control

Java-Only Rules

Utility methods that provide Java-only equivalents of standard ArchUnit rule definitions, essential for mixed Java/Scala projects.

public class GivenJavaClasses {
    public static ClassesThat<GivenClassesConjunction> javaClassesThat();
    public static GivenClassesConjunction javaClassesThat(DescribedPredicate<JavaClass> predicate);
    public static ClassesThat<GivenClassesConjunction> noJavaClassesThat();
}

Java-Only Rules

Source Predicates

Source-based predicates for filtering Java classes by source file characteristics, essential for mixed Java/Scala projects.

public class SourcePredicates {
    public static DescribedPredicate<JavaClass> areJavaClasses();
    static boolean isJavaClass(JavaClass clazz);
}

Source Predicates