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

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

/*-
 * #%L
 * assertj-bean-validation-javax
 * %%
 * Copyright (C) 2021 - 2022 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.AbstractAssert;
import org.assertj.core.api.AbstractBooleanAssert;
import org.assertj.core.api.AbstractClassAssert;
import org.assertj.core.api.AbstractComparableAssert;
import org.assertj.core.api.AbstractIntegerAssert;
import org.assertj.core.api.AbstractIterableAssert;
import org.assertj.core.api.AbstractListAssert;
import org.assertj.core.api.AbstractObjectAssert;
import org.assertj.core.api.AbstractStringAssert;
import org.assertj.core.api.AssertFactory;

import javax.validation.ElementKind;
import javax.validation.Path;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;

/**
 * An abstract class for verifying {@link Path} values.
 *
 * @param  self type parameter
 * @author Jin Kwon <onacit_at_gmail.com>
 */
@SuppressWarnings({
        "java:S119" // , 
})
public abstract class AbstractPathAssert<
        SELF extends AbstractPathAssert,
        NODE_ASSERT extends AbstractPathAssert.AbstractNodeAssert>
        extends AbstractIterableAssert
        implements PathAssert {

    abstract static class _AbstractNodeAssert<
            SELF extends _AbstractNodeAssert, ACTUAL extends Path.Node>
            extends AbstractAssert
            implements PathAssert.NodeAssert {

        _AbstractNodeAssert(final ACTUAL actual, final Class selfType) {
            super(actual, selfType);
        }

        // ------------------------------------------------------------------------------------------------------- index
        @Override
        public > ASSERT extractingIndex(
                final AssertFactory factory) {
            return isNotNull()
                    .extracting(Path.Node::getIndex, factory);
        }

        // --------------------------------------------------------------------------------------------------------- key
        @Override
        public > ASSERT extractingKey(
                final Function extractor,
                final AssertFactory factory) {
            Objects.requireNonNull(extractor, "extractor is null");
            return isNotNull()
                    .extracting(extractor, factory);
        }

        // -------------------------------------------------------------------------------------------------------- kind

        @Override
        public > ASSERT extractingKind(
                final AssertFactory factory) {
            return isNotNull()
                    .extracting(Path.Node::getKind, factory);
        }

        // -------------------------------------------------------------------------------------------------------- name

        @Override
        public > ASSERT extractingName(
                final AssertFactory factory) {
            return isNotNull()
                    .extracting(Path.Node::getName, factory);
        }

        // -------------------------------------------------------------------------------------------------- inIterable

        @Override
        public > ASSERT extractingInIterable(
                final AssertFactory factory) {
            return isNotNull()
                    .extracting(Path.Node::isInIterable, factory);
        }
    }

    public abstract static class AbstractNodeAssert>
            extends _AbstractNodeAssert {

        AbstractNodeAssert(final Path.Node actual, final Class selfType) {
            super(actual, selfType);
        }
    }

    abstract static class AbstractBeanNodeAssert>
            extends _AbstractNodeAssert
            implements BeanNodeAssert {

        AbstractBeanNodeAssert(final Path.BeanNode actual, final Class selfType) {
            super(actual, selfType);
        }

        @Override
        public > ASSERT extractingContainerClass(
                AssertFactory, ? extends ASSERT> factory) {
            return isNotNull()
                    .extracting(Path.BeanNode::getContainerClass, factory);
        }

        @Override
        public > ASSERT extractingTypeArgumentIndex(
                final AssertFactory factory) {
            return isNotNull()
                    .extracting(Path.BeanNode::getTypeArgumentIndex, factory);
        }
    }

    abstract static class AbstractConstructorNodeAssert>
            extends _AbstractNodeAssert
            implements ConstructorNodeAssert {

        AbstractConstructorNodeAssert(final Path.ConstructorNode actual, final Class selfType) {
            super(actual, selfType);
        }

        @Override
        public >, Class, ? extends AbstractClassAssert>>
        ASSERT extractingParameterTypes(final AssertFactory>, ? extends ASSERT> factory) {
            return isNotNull()
                    .extracting(Path.ConstructorNode::getParameterTypes, factory);
        }
    }

    abstract static class AbstractContainerElementNodeAssert>
            extends _AbstractNodeAssert
            implements ContainerElementNodeAssert {

        AbstractContainerElementNodeAssert(final Path.ContainerElementNode actual, final Class selfType) {
            super(actual, selfType);
        }

        @Override
        public > ASSERT extractingContainerClass(
                final AssertFactory, ? extends ASSERT> factory) {
            return isNotNull()
                    .extracting(Path.ContainerElementNode::getContainerClass, factory);
        }

        @Override
        public > ASSERT extractingTypeArgumentIndex(
                final AssertFactory factory) {
            return isNotNull()
                    .extracting(Path.ContainerElementNode::getTypeArgumentIndex, factory);
        }
    }

    abstract static class AbstractCrossParameterNodeAssert<
            SELF extends AbstractCrossParameterNodeAssert>
            extends _AbstractNodeAssert
            implements CrossParameterNodeAssert {

        AbstractCrossParameterNodeAssert(final Path.CrossParameterNode actual, final Class selfType) {
            super(actual, selfType);
        }
    }

    abstract static class AbstractMethodNodeAssert>
            extends _AbstractNodeAssert
            implements MethodNodeAssert {

        protected AbstractMethodNodeAssert(final Path.MethodNode actual, Class selfType) {
            super(actual, selfType);
        }

        @Override
        public >, Class, ? extends AbstractClassAssert>>
        ASSERT extractingParameterTypes(final AssertFactory>, ? extends ASSERT> factory) {
            return isNotNull()
                    .extracting(Path.MethodNode::getParameterTypes, factory);
        }
    }

    public abstract static class AbstractParameterNodeAssert>
            extends _AbstractNodeAssert
            implements ParameterNodeAssert {

        protected AbstractParameterNodeAssert(final Path.ParameterNode actual, final Class selfType) {
            super(actual, selfType);
        }

        @Override
        public > ASSERT extractingParameterIndex(
                final AssertFactory factory) {
            return isNotNull()
                    .extracting(Path.ParameterNode::getParameterIndex, factory);
        }
    }

    public abstract static class AbstractPropertyNodeAssert>
            extends _AbstractNodeAssert
            implements PropertyNodeAssert {

        protected AbstractPropertyNodeAssert(final Path.PropertyNode actual, final Class selfType) {
            super(actual, selfType);
        }

        @Override
        public > ASSERT extractingContainerClass(
                final AssertFactory, ? extends ASSERT> factory) {
            return isNotNull()
                    .extracting(Path.PropertyNode::getContainerClass, factory);
        }

        @Override
        public > ASSERT extractingTypeArgumentIndex(
                final AssertFactory factory) {
            return isNotNull()
                    .extracting(Path.PropertyNode::getTypeArgumentIndex, factory);
        }
    }

    public abstract static class AbstractReturnValueNodeAssert>
            extends _AbstractNodeAssert
            implements ReturnValueNodeAssert {

//        public static class DefaultReturnValueNodeAssert
//                extends AbstractReturnValueNodeAssert {
//
//            public DefaultReturnValueNodeAssert(final Path.ReturnValueNode actual) {
//                super(actual, DefaultReturnValueNodeAssert.class);
//            }
//        }

        protected AbstractReturnValueNodeAssert(final Path.ReturnValueNode actual, final Class selfType) {
            super(actual, selfType);
        }
    }

    // -----------------------------------------------------------------------------------------------------------------
    protected static Path.Node nodeAt(final Iterable iterable, final int index) {
        Objects.requireNonNull(iterable, "iterable is null");
        if (index < 0) {
            throw new IllegalArgumentException("negative index: " + index);
        }
        final Iterator iterator = iterable.iterator();
        Path.Node node = iterator.next(); // NoSuchElementException
        for (int i = 1; i < index; i++) {
            node = iterator.next(); // NoSuchElementException
        }
        return node;
    }

    protected static  N nodeAt(final Iterable iterable, final int index,
                                                    final Class nodeType) {
        final Path.Node node = nodeAt(iterable, index);
        if (nodeType == Path.Node.class) {
            @SuppressWarnings({"unchecked"})
            final N casted = (N) node;
            return casted;
        }
        return node.as(nodeType);
    }

    protected AbstractPathAssert(final Path actual, final Class selfType) {
        super(actual, selfType);
    }

    @Override
    public , N extends Path.Node> A extractingNode(
            final int index, final Class nodeType, final AssertFactory factory) {
        return isNotNull()
                .extracting(a -> nodeAt(a, index, nodeType), factory);
    }

    @Override
    public > A extractingNode(
            final int index, final AssertFactory factory) {
        return extractingNode(index, Path.Node.class, factory);
    }

    @Override
    public AbstractNodeAssert extractingNode(final int index) {
        return extractingNode(index, DefaultPathAssert.DefaultNodeAssert::new);
    }

    @Override
    public > A extractingBeanNode(
            final int index, AssertFactory factory) {
        return extractingNode(index, Path.BeanNode.class, factory);
    }

    @Override
    public AbstractBeanNodeAssert extractingBeanNode(final int index) {
        return extractingBeanNode(index, DefaultPathAssert.DefaultNodeAssert.DefaultBeanNodeAssert::new);
    }

    @Override
    public > A extractingPropertyNode(
            final int index, AssertFactory factory) {
        return extractingNode(index, Path.PropertyNode.class, factory);
    }

    @Override
    public AbstractPropertyNodeAssert extractingPropertyNode(final int index) {
        return extractingPropertyNode(index, DefaultPathAssert.DefaultNodeAssert.DefaultPropertyNodeAssert::new);
    }
}