org.hibernate.beanvalidation.tck.tests.traversableresolver.SnifferTraversableResolver Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of beanvalidation-tck-tests Show documentation

Jakarta Bean Validation TCK test suite

There is a newer version: 2.0.6

Show newest version

/**
 * Bean Validation TCK
 *
 * License: Apache License, Version 2.0
 * See the license.txt file in the root directory or .
 */
package org.hibernate.beanvalidation.tck.tests.traversableresolver;

import static org.testng.Assert.fail;

import java.lang.annotation.ElementType;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import javax.validation.Path;
import javax.validation.TraversableResolver;

/**
 * A {@link TraversableResolver} implementation used for asserting that the
 * actual calls to the resolver by the engine under test match the expected
 * calls.
 *
 * @author Emmanuel Bernard
 * @author Hardy Ferentschik
 */
public class SnifferTraversableResolver implements TraversableResolver {
	private int isReachableCallCount = 0;
	private int isCascadableCallCount = 0;
	private final Set expectedReachCalls = new HashSet();
	private final Set expectedCascadeCalls = new HashSet();
	private final Set executedReachableCalls = new HashSet();

	public SnifferTraversableResolver(Set expectedReachCalls, Set expectedCascadeCalls) {
		this.expectedReachCalls.addAll( expectedReachCalls );
		this.expectedCascadeCalls.addAll( expectedCascadeCalls );
	}

	public int getReachableCallCount() {
		return isReachableCallCount;
	}

	public int getCascadableCallCount() {
		return isCascadableCallCount;
	}

	@Override
	public boolean isReachable(Object traversableObject, Path.Node traversableProperty, Class rootBeanType, Path pathToTraversableObject, ElementType elementType) {
		List names = extractNodeName( pathToTraversableObject );
		Call call = new Call(
				traversableObject,
				traversableProperty.getName(),
				rootBeanType,
				elementType,
				names.toArray( new String[names.size()] )
		);
		executedReachableCalls.add( call );
		isReachableCallCount++;

		return assertIsExpectedCall(
				expectedReachCalls,
				call
		);
	}

	@Override
	public boolean isCascadable(Object traversableObject, Path.Node traversableProperty, Class rootBeanType, Path pathToTraversableObject, ElementType elementType) {
		List names = extractNodeName( pathToTraversableObject );
		Call call = new Call(
				traversableObject,
				traversableProperty.getName(),
				rootBeanType,
				elementType,
				names.toArray( new String[names.size()] )
		);
		if ( !executedReachableCalls.contains( call ) ) {
			throw new IllegalStateException( "isCascadable called before a matching  isReachable call: " + call.toString() );
		}

		isCascadableCallCount++;
		return assertIsExpectedCall(
				expectedCascadeCalls,
				call
		);
	}

	private boolean assertIsExpectedCall(Set calls, Call call) {
		if ( !calls.contains( call ) ) {
			fail( "Unexpected call to " + call.toString() );
		}
		return true;
	}

	private List extractNodeName(Path path) {
		LinkedList names = new LinkedList();
		Iterator iter = path.iterator();
		while ( iter.hasNext() ) {
			names.add( iter.next().getName() );
		}
		return names;
	}
}