TaskConfigurationAvoidanceTests Class — spring-boot Architecture

Source Code

build-plugin/spring-boot-gradle-plugin/src/test/java/org/springframework/boot/gradle/TaskConfigurationAvoidanceTests.java lines 43–158

@AnalyzeClasses(packages = "org.springframework.boot.gradle",
		importOptions = TaskConfigurationAvoidanceTests.DoNotIncludeTests.class)
class TaskConfigurationAvoidanceTests {

	@ArchTest
	void noApisThatCauseEagerTaskConfigurationShouldBeCalled(JavaClasses classes) {
		ProhibitedMethods prohibited = new ProhibitedMethods();
		prohibited.on(TaskContainer.class)
			.methodsNamed("create", "findByPath, getByPath")
			.method("withType", Class.class, Action.class);
		prohibited.on(TaskCollection.class).methodsNamed("findByName", "getByName");
		ArchRuleDefinition.noClasses()
			.should()
			.callMethodWhere(DescribedPredicate.describe("it would cause eager task configuration", prohibited))
			.check(classes);
	}

	static class DoNotIncludeTests implements ImportOption {

		@Override
		public boolean includes(Location location) {
			return !location.matches(Pattern.compile(".*Tests\\.class"));
		}

	}

	private static final class ProhibitedMethods implements Predicate<JavaMethodCall> {

		private final List<Predicate<JavaMethodCall>> prohibited = new ArrayList<>();

		private ProhibitedConfigurer on(Class<?> type) {
			return new ProhibitedConfigurer(type);
		}

		@Override
		public boolean test(JavaMethodCall methodCall) {
			for (Predicate<JavaMethodCall> spec : this.prohibited) {
				if (spec.test(methodCall)) {
					return true;
				}
			}
			return false;
		}

		private final class ProhibitedConfigurer {

			private final Class<?> type;

			private ProhibitedConfigurer(Class<?> type) {
				this.type = type;
			}

			private ProhibitedConfigurer methodsNamed(String... names) {
				for (String name : names) {
					ProhibitedMethods.this.prohibited.add(new ProhibitMethodsNamed(this.type, name));
				}
				return this;
			}

			private ProhibitedConfigurer method(String name, Class<?>... parameterTypes) {
				ProhibitedMethods.this.prohibited
					.add(new ProhibitMethod(this.type, name, Arrays.asList(parameterTypes)));
				return this;
			}

		}

		static class ProhibitMethodsNamed implements Predicate<JavaMethodCall> {

			private final Class<?> owner;

			private final String name;

			ProhibitMethodsNamed(Class<?> owner, String name) {
				this.owner = owner;
				this.name = name;
			}

			@Override
			public boolean test(JavaMethodCall methodCall) {
				return methodCall.getTargetOwner().isEquivalentTo(this.owner) && methodCall.getName().equals(this.name);
			}

		}

		private static final class ProhibitMethod extends ProhibitMethodsNamed {

			private final List<Class<?>> parameterTypes;

			private ProhibitMethod(Class<?> owner, String name, List<Class<?>> parameterTypes) {
				super(owner, name);
				this.parameterTypes = parameterTypes;
			}

			@Override
			public boolean test(JavaMethodCall methodCall) {
				return super.test(methodCall) && match(methodCall.getTarget().getParameterTypes());
			}

			private boolean match(List<JavaType> callParameterTypes) {
				if (this.parameterTypes.size() != callParameterTypes.size()) {
					return false;
				}
				for (int i = 0; i < this.parameterTypes.size(); i++) {
					if (!callParameterTypes.get(i).toErasure().isEquivalentTo(this.parameterTypes.get(i))) {
						return false;
					}
				}
				return true;
			}

		}

	}

}