com.tngtech.archunit.lang.ArchCondition Java Examples

@Test
public void shouldNotUseDefaultCurrentContext() {
	classes()
			.that().implement(CoreSubscriber.class)
			.and().doNotHaveModifier(JavaModifier.ABSTRACT)
			.should(new ArchCondition<JavaClass>("not use the default currentContext()") {
				@Override
				public void check(JavaClass item, ConditionEvents events) {
					boolean overridesMethod = item
							.getAllMethods()
							.stream()
							.filter(it -> "currentContext".equals(it.getName()))
							.filter(it -> it.getRawParameterTypes().isEmpty())
							.anyMatch(it -> !it.getOwner().isEquivalentTo(CoreSubscriber.class));

					if (!overridesMethod) {
						events.add(SimpleConditionEvent.violated(
								item,
								item.getFullName() + item.getSourceCodeLocation() + ": currentContext() is not overridden"
						));
					}
				}
			})
			.check(classes);
}
 

@Test
@UseDataProvider("member_syntax_testcases")
public void test_members(GivenMembers<JavaMember> members, String ruleStart, ArchCondition<JavaMember> condition,
        List<String> expectedViolationDetails) {
    ArchRule rule = members
            .that(have(modifier(PRIVATE)))
            .or(have(modifier(PROTECTED)))
            .and(are(annotatedWith(B.class)))
            .should(condition);

    assertThat(rule.getDescription()).as("rule description")
            .isEqualTo(ruleStart + " that have modifier PRIVATE or have modifier PROTECTED and are annotated with @B "
                    + "should " + condition.getDescription());

    EvaluationResult result = rule.evaluate(importClasses(ClassWithVariousMembers.class));

    assertViolation(result);
    assertThat(result.getFailureReport().getDetails()).containsOnlyElementsOf(expectedViolationDetails);
}
 

@Test
@UseDataProvider("resideOutsideOfPackage_rules")
public void resideOutsideOfPackage(ArchRule rule, String packageIdentifier) {
    checkTestStillValid(packageIdentifier,
            ImmutableSet.of(ArchRule.class, ArchCondition.class),
            ImmutableSet.<Class<?>>of(ArchConfiguration.class),
            ImmutableSet.<Class<?>>of(GivenObjects.class));

    EvaluationResult result = rule.evaluate(importClasses(
            ArchRule.class, ArchCondition.class, ArchConfiguration.class, GivenObjects.class));

    assertThat(singleLineFailureReportOf(result))
            .contains(String.format("classes should reside outside of package '%s'", packageIdentifier))
            .containsPattern(doesntResideOutsideOfPackagePatternFor(ArchRule.class, packageIdentifier))
            .containsPattern(doesntResideOutsideOfPackagePatternFor(ArchCondition.class, packageIdentifier))
            .doesNotContain(String.format("%s", ArchConfiguration.class.getSimpleName()))
            .doesNotContain(String.format("%s", GivenObjects.class.getSimpleName()));
}
 

private ArchCondition<Object> conditionWithDescription(String description) {
    return new ArchCondition<Object>(description) {
        @Override
        public void check(Object item, ConditionEvents events) {
        }
    };
}
 

@Override
public String toString() {
    return conjunction.should(new ArchCondition<Object>("removeMe") {
        @Override
        public void check(Object item, ConditionEvents events) {
        }
    }).getDescription().replace("should removeMe", "");
}
 

GivenMembersInternal(
        Priority priority,
        ClassesTransformer<JavaMember> classesTransformer,
        Function<ArchCondition<JavaMember>, ArchCondition<JavaMember>> prepareCondition) {

    this(new GivenMembersFactory(),
            priority,
            classesTransformer,
            prepareCondition,
            new PredicateAggregator<JavaMember>(),
            Optional.<String>absent());
}
 

@Override
@PublicAPI(usage = ACCESS)
public SliceRule beFreeOfCycles() {
    return new SliceRule(classesTransformer, priority, new SliceRule.ConditionFactory() {
        @Override
        public ArchCondition<Slice> create(Slices.Transformer transformer, DescribedPredicate<Dependency> predicate) {
            return new SliceCycleArchCondition(predicate);
        }
    });
}
 

@Override
@PublicAPI(usage = ACCESS)
public SliceRule notDependOnEachOther() {
    return new SliceRule(classesTransformer, priority, new SliceRule.ConditionFactory() {
        @Override
        public ArchCondition<Slice> create(Slices.Transformer transformer, DescribedPredicate<Dependency> predicate) {
            return new NotDependOnEachOtherCondition(predicate, transformer);
        }
    });
}
 

private static ArchCondition<JavaClass> beOkay() {
    return new ArchCondition<JavaClass>("be okay") {
        @Override
        public void check(JavaClass item, ConditionEvents events) {
        }
    };
}
 

GivenMethodsInternal(
        Priority priority,
        ClassesTransformer<JavaMethod> classesTransformer,
        Function<ArchCondition<JavaMethod>, ArchCondition<JavaMethod>> prepareCondition) {

    this(new GivenMethodsFactory(),
            priority,
            classesTransformer,
            prepareCondition,
            new PredicateAggregator<JavaMethod>(),
            Optional.<String>absent());
}
 

@Override
public GivenConstructorsInternal create(
        Priority priority,
        ClassesTransformer<JavaConstructor> classesTransformer,
        Function<ArchCondition<JavaConstructor>, ArchCondition<JavaConstructor>> prepareCondition,
        PredicateAggregator<JavaConstructor> relevantObjectsPredicates,
        Optional<String> overriddenDescription) {

    return new GivenConstructorsInternal(this,
            priority, classesTransformer, prepareCondition, relevantObjectsPredicates, overriddenDescription);
}
 

private static ArchCondition<JavaClass> satisfySomething() {
    return new ArchCondition<JavaClass>("satisfy something") {
        @Override
        public void check(JavaClass item, ConditionEvents events) {
        }
    };
}
 

static <T> AddMode<T> and(final Function<ArchCondition<T>, ArchCondition<T>> prepareCondition) {
    return new AddMode<T>() {
        @Override
        ArchCondition<T> apply(Optional<ArchCondition<T>> first, ArchCondition<? super T> other) {
            ArchCondition<T> second = prepareCondition.apply(other.<T>forSubType());
            return first.isPresent() ? first.get().and(second) : second;
        }
    };
}
 

@Override
public GivenObjectsInternal<T> create(Priority priority,
        ClassesTransformer<T> classesTransformer,
        Function<ArchCondition<T>, ArchCondition<T>> prepareCondition,
        PredicateAggregator<T> relevantObjectsPredicates,
        Optional<String> overriddenDescription) {

    return new GivenObjectsInternal<>(
            priority, classesTransformer, prepareCondition, relevantObjectsPredicates, overriddenDescription);
}
 

@Override
public GivenFieldsInternal create(
        Priority priority,
        ClassesTransformer<JavaField> classesTransformer,
        Function<ArchCondition<JavaField>, ArchCondition<JavaField>> prepareCondition,
        PredicateAggregator<JavaField> relevantObjectsPredicates,
        Optional<String> overriddenDescription) {

    return new GivenFieldsInternal(this,
            priority, classesTransformer, prepareCondition, relevantObjectsPredicates, overriddenDescription);
}
 

@PublicAPI(usage = ACCESS)
public static ArchCondition<JavaClass> callMethod(String ownerName, String methodName, String... parameterTypeNames) {
    return callMethodWhere(JavaCall.Predicates.target(With.<JavaClass>owner(name(ownerName)))
            .and(JavaCall.Predicates.target(name(methodName)))
            .and(JavaCall.Predicates.target(rawParameterTypes(parameterTypeNames))))
            .as("call method %s", Formatters.formatMethodSimple(
                    ensureSimpleName(ownerName), methodName, asList(parameterTypeNames)));
}
 

@PublicAPI(usage = ACCESS)
public static ArchCondition<JavaClass> onlyCallMethodsThat(final DescribedPredicate<? super JavaMethod> predicate) {
    ChainableFunction<JavaMethodCall, MethodCallTarget> getTarget = JavaAccess.Functions.Get.target();
    DescribedPredicate<JavaMethodCall> callPredicate = getTarget.then(MethodCallTarget.Functions.RESOLVE)
            .is(anyElementThat(predicate.<JavaMethod>forSubType()).or(empty()));
    return new ClassOnlyAccessesCondition<>(callPredicate, GET_METHOD_CALLS_FROM_SELF)
            .as("only call methods that " + predicate.getDescription());
}
 

@Test
void everySubpackageShouldBeTestsForCyclicDependencies() {
  List<Pattern> excludePackages =
      Stream.of(
              "pro.taskana", // from TaskanaEngineConfiguration
              "acceptance.*" // all our acceptance tests
              )
          .map(Pattern::compile)
          .collect(Collectors.toList());
  ArchCondition<JavaClass> condition =
      new ArchCondition<JavaClass>("all be defined in TASKANA_SUB_PACKAGES") {
        @Override
        public void check(JavaClass item, ConditionEvents events) {
          if (TASKANA_SUB_PACKAGES.stream().noneMatch(p -> item.getPackageName().startsWith(p))
              && excludePackages.stream()
                  .noneMatch(p -> p.matcher(item.getPackageName()).matches())) {
            String message =
                String.format(
                    "Package '%s' was not declared in TASKANA_SUB_PACKAGES",
                    item.getPackageName());
            events.add(SimpleConditionEvent.violated(item, message));
          }
        }
      };
  ArchRule myRule = classes().should(condition);
  myRule.check(importedClasses);
}
 

MethodsShouldInternal(
        ClassesTransformer<? extends JavaMethod> classesTransformer,
        Priority priority,
        Function<ArchCondition<JavaMethod>, ArchCondition<JavaMethod>> prepareCondition) {

    super(classesTransformer, priority, prepareCondition);
}
 

GivenFieldsInternal(
        Priority priority,
        ClassesTransformer<JavaField> classesTransformer,
        Function<ArchCondition<JavaField>, ArchCondition<JavaField>> prepareCondition) {

    super(new GivenFieldsFactory(),
            priority,
            classesTransformer,
            prepareCondition,
            new PredicateAggregator<JavaField>(),
            Optional.<String>absent());
}
 

@PublicAPI(usage = ACCESS)
public static ArchCondition<JavaClass> dependOnClassesThat(final DescribedPredicate<? super JavaClass> predicate) {
    return new AnyDependencyCondition(
            "depend on classes that " + predicate.getDescription(),
            GET_TARGET_CLASS.is(predicate),
            GET_DIRECT_DEPENDENCIES_FROM_SELF);
}
 

@PublicAPI(usage = ACCESS)
public static ArchCondition<JavaClass> onlyDependOnClassesThat(final DescribedPredicate<? super JavaClass> predicate) {
    return new AllDependenciesCondition(
            "only depend on classes that " + predicate.getDescription(),
            GET_TARGET_CLASS.is(predicate),
            GET_DIRECT_DEPENDENCIES_FROM_SELF);
}
 

private GivenMethodsInternal(
        Factory<JavaMethod, GivenMethodsInternal> factory,
        Priority priority,
        ClassesTransformer<JavaMethod> classesTransformer,
        Function<ArchCondition<JavaMethod>, ArchCondition<JavaMethod>> prepareCondition,
        PredicateAggregator<JavaMethod> relevantObjectsPredicates,
        Optional<String> overriddenDescription) {

    super(factory, priority, classesTransformer, prepareCondition, relevantObjectsPredicates, overriddenDescription);
}
 

/**
 * @param packageIdentifiers Strings identifying a package according to {@link PackageMatcher}
 * @return A condition matching accesses to packages matching any of the identifiers
 */
@PublicAPI(usage = ACCESS)
public static ArchCondition<JavaClass> accessClassesThatResideInAnyPackage(String... packageIdentifiers) {
    JavaAccessPackagePredicate predicate = JavaAccessPackagePredicate.forAccessTarget().matching(packageIdentifiers);
    return new ClassAccessesCondition<>(predicate, GET_ACCESSES_FROM_SELF)
            .as("access classes that reside in " + predicate);
}
 

private GivenConstructorsInternal(
        Factory<JavaConstructor, GivenConstructorsInternal> factory,
        Priority priority,
        ClassesTransformer<JavaConstructor> classesTransformer,
        Function<ArchCondition<JavaConstructor>, ArchCondition<JavaConstructor>> prepareCondition,
        PredicateAggregator<JavaConstructor> relevantObjectsPredicates,
        Optional<String> overriddenDescription) {

    super(factory, priority, classesTransformer, prepareCondition, relevantObjectsPredicates, overriddenDescription);
}
 

/**
 * @param packageIdentifiers Strings identifying packages according to {@link PackageMatcher}
 * @return A condition matching {@link JavaClass classes} that have other classes
 * depending on them (e.g. calling methods of this class)
 * with a package matching any of the identifiers
 */
@PublicAPI(usage = ACCESS)
public static ArchCondition<JavaClass> onlyHaveDependentsInAnyPackage(String... packageIdentifiers) {
    String description = String.format("only have dependents in any package ['%s']",
            Joiner.on("', '").join(packageIdentifiers));
    return onlyHaveDependentsWhere(dependencyOrigin(GET_PACKAGE_NAME.is(PackageMatchers.of(packageIdentifiers))))
            .as(description);
}
 

public List<T> on(Class<?>... toCheck) {
    final List<T> result = new ArrayList<>();
    JavaClasses classes = importClassesWithContext(toCheck);
    ArchCondition<T> condition = new ArchCondition<T>("ignored") {
        @Override
        public void check(T item, ConditionEvents events) {
            result.add(item);
        }
    };
    givenObjects.should(condition).check(classes);
    return result;
}
 

AbstractGivenCodeUnitsInternal(
        Factory<MEMBER, SELF> factory,
        Priority priority,
        ClassesTransformer<MEMBER> classesTransformer,
        Function<ArchCondition<MEMBER>, ArchCondition<MEMBER>> prepareCondition,
        PredicateAggregator<MEMBER> relevantObjectsPredicates,
        Optional<String> overriddenDescription) {

    super(factory, priority, classesTransformer, prepareCondition, relevantObjectsPredicates, overriddenDescription);
}
 

@Override
public GivenCodeUnitsInternal create(
        Priority priority,
        ClassesTransformer<JavaCodeUnit> classesTransformer,
        Function<ArchCondition<JavaCodeUnit>, ArchCondition<JavaCodeUnit>> prepareCondition,
        PredicateAggregator<JavaCodeUnit> relevantObjectsPredicates,
        Optional<String> overriddenDescription) {

    return new GivenCodeUnitsInternal(this,
            priority, classesTransformer, prepareCondition, relevantObjectsPredicates, overriddenDescription);
}
 

private Set<Slice> getSlicesMatchedByFilter(GivenConjunction<Slice> givenSlices) {
    final Set<Slice> matched = new HashSet<>();
    givenSlices.should(new ArchCondition<Slice>("") {
        @Override
        public void check(Slice item, ConditionEvents events) {
            matched.add(item);
        }
    }).evaluate(new ClassFileImporter().importPackages(TEST_CLASSES_PACKAGE));
    return matched;
}