com.github.jinahya.assertj.validation.PathAssert Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of assertj-bean-validation-generic Show documentation
An AssertJ extension for Bean-Validation
The newest version!
package com.github.jinahya.assertj.validation;

/*-
 * #%L
 * assertj-bean-validation
 * %%
 * Copyright (C) 2021 Jinahya, Inc.
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */

import org.assertj.core.api.ClassBasedNavigableIterableAssert;

import java.util.List;

import static com.github.jinahya.assertj.validation.PathUtils.NodeUtils.requireNullOrInstanceOfNodeClass;
import static com.github.jinahya.assertj.validation.PathUtils.PropertyNodeUtils.requireNullOrInstanceOfPropertyNodeClass;
import static com.github.jinahya.assertj.validation.PathUtils.requireNullOrInstanceOfPathClass;

/**
 * An assertion class for verifying instances of {@code ....validation.Path}.
 *
 * @author Jin Kwon <onacit_at_gmail.com>
 */
@SuppressWarnings({"java:S119", "java:S125"})
public class PathAssert
        extends AbstractPathAssert {

    // ------------------------------------------------------------------------------------------------------------ Node
    static class NodeAssertDelegateImpl
            implements AbstractNodeAccessor {

        @Override
        public Integer getIndex(final Object actual) {
            return PathUtils.NodeUtils.getIndex(actual);
        }

        @Override
        public Object getKey(final Object actual) {
            return PathUtils.NodeUtils.getKey(actual);
        }

        @Override
        public Object getKind(final Object actual) {
            return PathUtils.NodeUtils.getKind(actual);
        }

        @Override
        public String getName(final Object actual) {
            return PathUtils.NodeUtils.getName(actual);
        }

        @Override
        public boolean isInIterable(final Object actual) {
            return PathUtils.NodeUtils.isInIterable(actual);
        }
    }

    public static class NodeAssert
            extends AbstractNodeAssert {

        public NodeAssert(final Object actual) {
            super(requireNullOrInstanceOfNodeClass(actual), NodeAssert.class, new NodeAssertDelegateImpl());
        }

        @Override
        public NodeAssert isBeanNode() {
            return isNotNull().isInstanceOf(PathUtils.BeanNodeUtils.BEAN_NODE_CLASS);
        }

        @SuppressWarnings({"unchecked"})
        @Override
        public BeanNodeAssert asBeanNode() {
            return new BeanNodeAssert(actual);
        }

        @Override
        public NodeAssert isConstructorNode() {
            return isNotNull().isInstanceOf(PathUtils.ConstructorNodeUtils.CONSTRUCTOR_NODE_CLASS);
        }

        @SuppressWarnings({"unchecked"})
        @Override
        public ConstructorNodeAssert asConstructorNode() {
            return new ConstructorNodeAssert(actual);
        }

        @Override
        public NodeAssert isCrossParameterNode() {
            return isNotNull().isInstanceOf(PathUtils.CrossParameterNodeUtils.CROSS_PARAMETER_NODE_CLASS);
        }

        @SuppressWarnings({"unchecked"})
        @Override
        public CrossParameterNodeAssert asCrossParameterNode() {
            return new CrossParameterNodeAssert(actual);
        }

        @Override
        public NodeAssert isMethodNode() {
            return isNotNull().isInstanceOf(PathUtils.MethodNodeUtils.METHOD_NODE_CLASS);
        }

        @SuppressWarnings({"unchecked"})
        @Override
        public MethodNodeAssert asMethodNode() {
            return new MethodNodeAssert(actual);
        }

        @Override
        public NodeAssert isParameterNode() {
            return isNotNull().isInstanceOf(PathUtils.ParameterNodeUtils.PARAMETER_NODE_CLASS);
        }

        @SuppressWarnings({"unchecked"})
        @Override
        public ParameterNodeAssert asParameterNode() {
            return new ParameterNodeAssert(actual);
        }

        @Override
        public NodeAssert isPropertyNode() {
            return isNotNull().isInstanceOf(PathUtils.PropertyNodeUtils.PROPERTY_NODE_CLASS);
        }

        @SuppressWarnings({"unchecked"})
        @Override
        public PropertyNodeAssert asPropertyNode() {
            return new PropertyNodeAssert(actual);
        }

        @Override
        public NodeAssert isReturnValueNode() {
            return isNotNull().isInstanceOf(PathUtils.ReturnValueNodeUtils.RETURN_VALUE_NODE_CLASS);
        }

        @SuppressWarnings({"unchecked"})
        @Override
        public ReturnValueNodeAssert asReturnValueNode() {
            return new ReturnValueNodeAssert(actual);
        }
    }

    // -------------------------------------------------------------------------------------------------------- BeanNode
    static class BeanNodeAssertDelegateImpl
            extends NodeAssertDelegateImpl
            implements BeanNodeAccessor {

        @Override
        public Class getContainerClass(final Object a) {
            return PathUtils.BeanNodeUtils.getContainerClass(a);
        }

        @Override
        public Integer getTypeArgumentIndex(Object a) {
            return PathUtils.BeanNodeUtils.getTypeArgumentIndex(a);
        }
    }

    public static class BeanNodeAssert
            extends AbstractBeanNodeAssert {

        public BeanNodeAssert(Object actual) {
            super(PathUtils.BeanNodeUtils.requireNullOrInstanceOfBeanNodeClass(actual), BeanNodeAssert.class,
                  new BeanNodeAssertDelegateImpl());
        }
    }

    // ------------------------------------------------------------------------------------------------- ConstructorNode
    static class ConstructorNodeAccessorImpl
            extends NodeAssertDelegateImpl
            implements ConstructorNodeAccessor {

        @Override
        public List> getParameterTypes(final Object a) {
            return PathUtils.ConstructorNodeUtils.getParameterTypes(a);
        }
    }

    public static class ConstructorNodeAssert
            extends AbstractConstructorNodeAssert {

        public ConstructorNodeAssert(final Object actual) {
            super(PathUtils.ConstructorNodeUtils.requireNullOrInstanceOfConstructorNodeClass(actual),
                  ConstructorNodeAssert.class, new ConstructorNodeAccessorImpl());
        }
    }

    // -------------------------------------------------------------------------------------------- ContainerElementNode
    static class ContainerElementNodeAccessorImpl
            extends NodeAssertDelegateImpl
            implements ContainerElementNodeAccessor {

        @Override
        public Class getContainerClass(Object a) {
            return PathUtils.ContainerElementNodeUtils.getContainerClass(a);
        }

        @Override
        public Integer getTypeArgumentIndex(Object a) {
            return PathUtils.ContainerElementNodeUtils.getTypeArgumentIndex(a);
        }
    }

    public static class ContainerElementNodeAssert
            extends AbstractContainerElementNodeAssert {

        public ContainerElementNodeAssert(final Object actual) {
            super(PathUtils.ContainerElementNodeUtils.requireNullOrInstanceOfContainerElementNodeClass(actual),
                  ContainerElementNodeAssert.class, new ContainerElementNodeAccessorImpl());
        }
    }

    // ---------------------------------------------------------------------------------------------- CrossParameterNode
    static class CrossParameterNodeAccessorImpl
            extends NodeAssertDelegateImpl
            implements CrossParameterNodeAccessor {

    }

    public static class CrossParameterNodeAssert
            extends AbstractCrossParameterNodeAssert {

        public CrossParameterNodeAssert(final Object actual) {
            super(PathUtils.CrossParameterNodeUtils.requireNullOrInstanceOfCrossParameterNodeClass(actual),
                  CrossParameterNodeAssert.class, new CrossParameterNodeAccessorImpl());
        }
    }

    // ------------------------------------------------------------------------------------------------------ MethodNode
    static class MethodNodeAccessorImpl
            extends NodeAssertDelegateImpl
            implements MethodNodeAccessor {

        @Override
        public List> getParameterTypes(final Object a) {
            return PathUtils.MethodNodeUtils.getParameterTypes(a);
        }
    }

    public static class MethodNodeAssert
            extends AbstractMethodNodeAssert {

        public MethodNodeAssert(final Object actual) {
            super(PathUtils.MethodNodeUtils.requireNullOrInstanceOfMethodNodeClass(actual), MethodNodeAssert.class,
                  new MethodNodeAccessorImpl());
        }
    }

    // --------------------------------------------------------------------------------------------------- ParameterNode
    static class ParameterNodeAccessorImpl
            extends NodeAssertDelegateImpl
            implements ParameterNodeAccessor {

        @Override
        public int getParameterIndex(Object a) {
            return PathUtils.ParameterNodeUtils.getParameterIndex(a);
        }
    }

    public static class ParameterNodeAssert
            extends AbstractParameterNodeAssert {

        public ParameterNodeAssert(final Object actual) {
            super(PathUtils.ParameterNodeUtils.requireNullOrInstanceOfParameterNodeClass(actual),
                  ParameterNodeAssert.class, new ParameterNodeAccessorImpl());
        }
    }

    // ---------------------------------------------------------------------------------------------------- PropertyNode
    static class PropertyNodeAccessorImpl
            extends NodeAssertDelegateImpl
            implements PropertyNodeAccessor {

        @Override
        public Class getContainerClass(final Object a) {
            return PathUtils.PropertyNodeUtils.getContainerClass(a);
        }

        @Override
        public Integer getTypeArgumentIndex(Object a) {
            return PathUtils.PropertyNodeUtils.getTypeArgumentIndex(a);
        }
    }

    public static class PropertyNodeAssert
            extends AbstractPropertyNodeAssert {

        public PropertyNodeAssert(Object actual) {
            super(requireNullOrInstanceOfPropertyNodeClass(actual), PropertyNodeAssert.class,
                  new PropertyNodeAccessorImpl());
        }
    }

    // ------------------------------------------------------------------------------------------------- ReturnValueNode
    static class ReturnValueNodeAccessorImpl
            extends NodeAssertDelegateImpl
            implements ReturnValueNodeAccessor {

    }

    public static class ReturnValueNodeAssert
            extends AbstractReturnValueNodeAssert {

        public ReturnValueNodeAssert(final Object actual) {
            super(PathUtils.ReturnValueNodeUtils.requireNullOrInstanceOfReturnValueNodeClass(actual),
                  ReturnValueNodeAssert.class, new ReturnValueNodeAccessorImpl());
        }
    }

    // -----------------------------------------------------------------------------------------------------------------
    // should be public for accessing methods defined AbstractIterableAssert
    // say, asIterable().hasSize(1)
    public static class PathAsIterableNodeAssert
            extends ClassBasedNavigableIterableAssert, Object, NodeAssert> {

        PathAsIterableNodeAssert(final Iterable