Java Code Examples for com.tngtech.archunit.lang.ArchRule#check()

@Override
Result evaluateOn(JavaClasses classes) {
    ArchRule rule = getValue(ruleField, testClass);
    try {
        rule.check(classes);
    } catch (Exception | AssertionError e) {
        return new NegativeResult(describeSelf(), e);
    }
    return new PositiveResult();
}
 

@Test
void exceptionsShouldBePlacedInExceptionPackage() {
  ArchRule myRule =
      classes()
          .that()
          .haveSimpleNameEndingWith("Exception")
          .should()
          .resideInAPackage("..exceptions..");

  myRule.check(importedClasses);
}
 

@Test
public void publicControllerMethodsShouldBeAnnotatedWithARequestMapping() {
  ArchRule rule = ArchRuleDefinition.methods()
    .that().arePublic()
    .and().areDeclaredInClassesThat().resideInAPackage("..adapters.primary.web..")
    .and().areDeclaredInClassesThat().haveSimpleNameEndingWith("Controller")
    .and().areDeclaredInClassesThat().areAnnotatedWith(Controller.class)
    .or().areDeclaredInClassesThat().areAnnotatedWith(RestController.class)
    .should().beAnnotatedWith(RequestMapping.class)
    .orShould().beAnnotatedWith(GetMapping.class)
    .orShould().beAnnotatedWith(PostMapping.class)
    .orShould().beAnnotatedWith(PatchMapping.class)
    .orShould().beAnnotatedWith(DeleteMapping.class);
  rule.check(classes);
}
 

@ArchTest
public static void aggregateAnnotationRules(JavaClasses importedClasses) {
    ArchRule namingToAnnotation = classes().that().haveSimpleNameEndingWith("Aggregate").should().beAnnotatedWith(Aggregate.class);
    namingToAnnotation.check(importedClasses);

    ArchRule annotationToNaming = classes().that().areAnnotatedWith(Aggregate.class).should().haveSimpleNameEndingWith("Aggregate");
    annotationToNaming.check(importedClasses);
}
 

@Test
public void documentClassesShouldBeAnnotatedWithDocumentAnnotation() {
  ArchRule rule = ArchRuleDefinition.classes()
    .that().haveSimpleNameEndingWith("Document")
    .should().beAnnotatedWith(Document.class);
  rule.check(classes);
}
 

@Test
public void noClassesWithRepositoryAnnotationShouldResideOutsideOfSecondaryAdaptersPackages() {
  ArchRule rule = ArchRuleDefinition.noClasses()
    .that().areAnnotatedWith(Repository.class)
    .should().resideOutsideOfPackage(SECONDARY_ADAPTERS_PACKAGES);
  rule.check(classes);
}
 

private static void checkRuleAndIgnoreFailure(JavaClasses classes, ArchRule rule) {
    try {
        rule.check(classes);
        throw new RuntimeException("Should have thrown an " + AssertionError.class.getSimpleName());
    } catch (AssertionError ignored) {
    }
}
 

@Test
public void controllerClassesShouldBeAnnotatedWithControllerOrRestControllerAnnotation() {
  ArchRule rule = ArchRuleDefinition.classes()
    .that().haveSimpleNameEndingWith("Controller")
    .should().beAnnotatedWith(Controller.class)
    .orShould().beAnnotatedWith(RestController.class);
  rule.check(classes);
}
 

@Test
public void testUtils() {
	JavaClasses importedClasses = new ClassFileImporter().importPackages("org.firehol");

	final ArchRule rule = classes().that()
			.haveSimpleNameEndingWith("Utils")
			.should()
			.haveModifier(JavaModifier.FINAL)
			.andShould()
			.haveOnlyPrivateConstructors();

	rule.check(importedClasses);
}
 

@Test
public void springSingletonComponentsShouldOnlyHaveFinalFields() {
  ArchRule rule = ArchRuleDefinition.classes()
    .that().areAnnotatedWith(Service.class)
    .or().areAnnotatedWith(Component.class)
    .and().areNotAnnotatedWith(ConfigurationProperties.class)
    .or().areAnnotatedWith(Controller.class)
    .or().areAnnotatedWith(RestController.class)
    .or().areAnnotatedWith(Repository.class)
    .should().haveOnlyFinalFields();
  rule.check(classes);
}
 

@Test
public void domainClassesShouldOnlyDependOnDomainOrStdLibClasses() {
  ArchRule rule = ArchRuleDefinition.classes()
    .that().resideInAPackage(DOMAIN_LAYER_PACKAGES)
    .should().onlyDependOnClassesThat().resideInAnyPackage(DOMAIN_LAYER_PACKAGES, "java..");
  rule.check(classes);
}
 

@Test
public void domainClassesShouldOnlyBeAccessedByOtherDomainClassesOrTheApplicationLayer() {
  ArchRule rule = ArchRuleDefinition.classes()
    .that().resideInAPackage(DOMAIN_LAYER_PACKAGES)
    .should().onlyBeAccessed().byAnyPackage(DOMAIN_LAYER_PACKAGES, APPLICATION_LAYER_PACKAGES);
  rule.check(classes);
}
 

@Test
public void useCaseClassesShouldHaveAnInvokeMethodWithASingleRequestParameterAndAResponseReturnType() {
  ArchRule rule = ArchRuleDefinition.classes()
    .that().haveSimpleNameEndingWith("UseCase")
    .should(new HaveAnInvokeMethodWithASingleRequestParameterAndAResponseReturnType());
  rule.check(classes);
}
 

@Test
public void noClassesWithServiceAnnotationShouldResideOutsideTheApplicationLayer() {
  ArchRule rule = ArchRuleDefinition.noClasses()
    .that().areAnnotatedWith(Service.class)
    .should().resideOutsideOfPackage(APPLICATION_LAYER_PACKAGES);
  rule.check(classes);
}
 

@Test
public void useCaseClassesShouldBeAnnotatedWithServiceAnnotation() {
  ArchRule rule = ArchRuleDefinition.classes()
    .that().haveSimpleNameEndingWith("UseCase")
    .should().beAnnotatedWith(Service.class);
  rule.check(classes);
}
 

@Test
void onlyExceptionsShouldResideInExceptionPackage() {
  ArchRule myRule =
      classes().that().resideInAPackage("..exceptions").should().beAssignableTo(Throwable.class);
  myRule.check(importedClasses);
}
 

@Test
public void noClassesShouldUseStandardStreams() {
  ArchRule rule = ArchRuleDefinition.noClasses()
    .should(GeneralCodingRules.ACCESS_STANDARD_STREAMS);
  rule.check(classes);
}
 

@Test
public void noClassesShouldUseStandardLogging() {
  ArchRule rule = ArchRuleDefinition.noClasses()
    .should(GeneralCodingRules.USE_JAVA_UTIL_LOGGING);
  rule.check(classes);
}
 

@Test
public void domainLayerShouldOnlyBeAccessedByApplicationLayer() {
  ArchRule rule = portsAndAdaptersArchitecture.whereLayer(DOMAIN_LAYER)
    .mayOnlyBeAccessedByLayers(APPLICATION_LAYER);
  rule.check(classes);
}
 

@Test
public void adaptersLayerShouldNotBeAccessedByAnyLayer() {
  ArchRule rule = portsAndAdaptersArchitecture.whereLayer(ADAPTERS_LAYER)
    .mayNotBeAccessedByAnyLayer();
  rule.check(classes);
}