enofex / taikai

Taikai is an extension of the popular ArchUnit library, offering a comprehensive suite of predefined rules tailored for various technologies.

Taikai

Taikai extends the capabilities of the popular ArchUnit library by offering a comprehensive suite of predefined rules tailored for various technologies. It simplifies the enforcement of architectural constraints and best practices in your codebase, ensuring consistency and quality across your projects.

Maven Usage

Add Taikai as a dependency in your pom.xml:

<dependency>
  <groupId>com.enofex</groupId>
  <artifactId>taikai</artifactId>
  <version>${taikai.version}</version>
  <scope>test</scope>
</dependency>

Replace ${taikai.version} with the appropriate version defined in your project. Ensure that the required dependencies like ArchUnit are already declared.

JUnit 5 Example Test

Here's an example demonstrating the usage of Taikai with JUnit 5. Customize rules as needed using TaikaiRule.of().

@Test
void shouldFulfillConstraints() {
  Taikai.builder()
      .namespace("com.enofex.taikai")
      .java(java -> java
          .noUsageOfDeprecatedAPIs()
          .methodsShouldNotDeclareGenericExceptions()
          .utilityClassesShouldBeFinalAndHavePrivateConstructor()
          .imports(imports -> imports
              .shouldHaveNoCycles()
              .shouldNotImport("..shaded..")
              .shouldNotImport("org.junit.."))
          .naming(naming -> naming
              .classesShouldNotMatch(".*Impl")
              .methodsShouldNotMatch("foo")
              .fieldsShouldNotMatch("bar")
              .fieldsShouldMatch("com.awesome.Foo", "foo")
              .constantsShouldFollowConventions()
              .interfacesShouldNotHavePrefixI()))
      .logging(logging -> logging
          .loggersShouldFollowConventions(Logger.class, "logger", EnumSet.of(PRIVATE, FINAL)))      
      .test(test -> test
          .junit5(junit5 -> junit5
              .classesShouldNotBeAnnotatedWithDisabled()
              .methodsShouldNotBeAnnotatedWithDisabled()))
      .spring(spring -> spring
          .noAutowiredFields()
          .boot(boot -> boot
              .springBootApplicationShouldBeIn("com.enofex.taikai"))
          .configurations(configuration -> configuration
              .namesShouldEndWithConfiguration())
          .controllers(controllers -> controllers
              .shouldBeAnnotatedWithRestController()
              .namesShouldEndWithController()
              .shouldNotDependOnOtherControllers()
              .shouldBePackagePrivate())
          .services(services -> services
              .shouldBeAnnotatedWithService()
              .shouldNotDependOnControllers()
              .namesShouldEndWithService())
          .repositories(repositories -> repositories
              .shouldBeAnnotatedWithRepository()
              .shouldNotDependOnServices()
              .namesShouldEndWithRepository()))      
      .addRule(TaikaiRule.of(...)) // Add custom ArchUnit rule here
      .build()
      .check();
}

User Guide

Explore the complete documentation for comprehensive information on all available rules.

Contributing

Interested in contributing? Check out our Contribution Guidelines for details on how to get involved. Note, that we expect everyone to follow the Code of Conduct.

What you will need

• Git
• Java 21 or higher

Get the Source Code

Clone the repository

git clone [email protected]:enofex/taikai.git
cd taikai

Build the code

To compile, test, and build

./mvnw clean package -B

taikai's Issues

Provide a new JUnit 5 Rule checking test methods are using DisplayName

Ensure that all test methods use @DisplayName to provide more descriptive test names.

Provide a New Naming Rule checking if classes annotated with special annotation match naming

Provide a New Logging Rule checking logger consistent usage

Provide a new Spring Rule checking that controller methods return ResponseEntity

Provide a new Java Rule checking if final classes do not have protected members

Ensure that final classes do not have protected members.

Provide a new JUnit Rule checking if method names match name

User guide is empty

In the readme documentation refers to the file https://github.com/enofex/taikai/blob/main/docs/USERGUIDE.md which is empty

Allow global exclusions of classes

Provide a New Java Rule checking if a class is not used

.noUsageOf(Date.class)
.noUsageOf(“SomeClass“)

Provide a new Java Naming Rule checking if fields of a specific type match a regex

Provide a new Java Rule checking serialVersionUID is static final long

Provide a new JUnit 5 Rule checking test classes are package private

Ensure that test classes are package-private, reducing their visibility outside the test package.

Provide a new Spring Rule checking that repositories do not depend on services

Provide a New Java Rule checking if System.out and System.err is not used

Add Support for Centralized Configuration of Rules Across Multiple Projects Using YAML

Currently, the configuration for each project's rules is handled individually, which can lead to inconsistencies and difficulties in managing multiple projects. To streamline this process, we propose using a YAML configuration file to define the namespace, rules, and other settings for multiple projects in a centralized manner. This will ensure consistency and ease of management.

Related to #42

Provide a new JUnit 5 Rule checking test methods are package private

Ensure that test methods are package-private, reducing their visibility outside the test package.

Provide a New Naming Rule checking if methods not match naming

Provide a new JUnit 5 Rule checking if the test methods do not declare any thrown exceptions

Ensure that test methods do not declare any thrown exceptions.

Provide a new Logging Rule checking a Logger Usage Based on Classes Matching Regex

Provide a New Naming Rule checking if methods annotated with special annotation match naming

Provide a New Naming Rule checking if fields annotated with special annotation match naming

Provide a New Naming Rule checking if fields not match naming

Rule springBootApplicationShouldBeIn should not check for meta annotation

Add Possibility of Modifying an Existing Configuration

Provide a New Java Rule checking fields by disallowing public fields

Provide a new Spring Rule checking that service classes do not depend on controllers

Offer taikai rules through arch-unit-maven-plugin

Hi there,

I am following the activity in the project, which seems great by the way!

One thing I would like to know if it is been considered already, is providing Taikai with/within arch-unit-maven-plugin: https://github.com/societe-generale/arch-unit-maven-plugin

Because if I have many modules and would like to run against all of them, would be better to run trough the plugin instead of replicating the same rules all over the place.

Do you consider it a feasible idea or do you have another approach in mind?

Provide a new Java Rule checking equals and hashCode are implemented together

Allow exclusions of classes per rule

Provide a new Java Rule for enforcing naming conventions for constants

Fields that are constants (static final) should be in uppercase with words separated by underscores and should be declared with the final keyword.