• Home
• net.javacrumbs.json-unit
• json-unit
• 3.2.5
• source code
• JsonMatchers.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

net.javacrumbs.jsonunit.JsonMatchers Maven / Gradle / Ivy

/**
 * Copyright 2009-2019 the original author or authors.
 *
 * 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.
 */
package net.javacrumbs.jsonunit;

import static net.javacrumbs.jsonunit.core.internal.Diff.createInternal;
import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getNode;
import static net.javacrumbs.jsonunit.core.internal.JsonUtils.getPathPrefix;
import static net.javacrumbs.jsonunit.core.internal.JsonUtils.nodeAbsent;

import java.math.BigDecimal;
import java.util.Collection;
import java.util.IdentityHashMap;
import java.util.Map;
import net.javacrumbs.jsonunit.core.Configuration;
import net.javacrumbs.jsonunit.core.ConfigurationWhen.ApplicableForPath;
import net.javacrumbs.jsonunit.core.ConfigurationWhen.PathsParam;
import net.javacrumbs.jsonunit.core.Option;
import net.javacrumbs.jsonunit.core.internal.Diff;
import net.javacrumbs.jsonunit.core.internal.Node;
import net.javacrumbs.jsonunit.core.internal.Path;
import net.javacrumbs.jsonunit.core.listener.DifferenceListener;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Matcher;

/**
 * Contains Hamcrest matchers to be used with Hamcrest assertThat and other tools.
 * 

 * All the methods accept Objects as parameters. The supported types are:
 * 

 * 
Jackson JsonNode
 * 
Numbers, booleans and any other type parseable by Jackson's ObjectMapper.convertValue
 * 
String is parsed as JSON. For expected values the string is quoted if it contains obviously invalid JSON.
 * 
{@link java.io.Reader} similarly to String
 * 
null as null Node
 * 
 */
public class JsonMatchers {

    private static final String EMPTY_PATH = "";
    private static final String FULL_JSON = "fullJson";

    /**
     * Are the JSONs equivalent?
     */
    public static  ConfigurableJsonMatcher jsonEquals(Object expected) {
        return new JsonPartMatcher<>(EMPTY_PATH, expected);
    }

    /**
     * Is the part of the JSON equivalent?
     */
    public static  ConfigurableJsonMatcher jsonPartEquals(String path, Object expected) {
        return new JsonPartMatcher<>(path, expected);
    }

    /**
     * Applies matcher to the part of the JSON.
     */
    public static  Matcher jsonPartMatches(String path, Matcher matcher) {
        return new MatcherApplyingMatcher<>(path, matcher);
    }

    /**
     * Are the JSONs equivalent?
     * 

     * This method exist only for those cases, when you need to use it as Matcher<String> and Java refuses to
     * do the type inference correctly.
     */
    public static ConfigurableJsonMatcher jsonStringEquals(Object expected) {
        return jsonEquals(expected);
    }

    /**
     * Is the part of the JSON equivalent?
     * 

     * This method exist only for those cases, when you need to use it as Matcher<String> and Java refuses to
     * do the type inference correctly.
     */
    public static ConfigurableJsonMatcher jsonStringPartEquals(String path, Object expected) {
        return jsonPartEquals(path, expected);
    }

    /**
     * Is the node in path absent?
     */
    public static  ConfigurableJsonMatcher jsonNodeAbsent(String path) {
        return new JsonNodeAbsenceMatcher<>(path);
    }

    /**
     * Is the node in path present?
     */
    public static  ConfigurableJsonMatcher jsonNodePresent(String path) {
        return new JsonNodePresenceMatcher<>(path);
    }

    private abstract static class AbstractMatcher extends BaseMatcher {
        final String path;
        Object actual;

        AbstractMatcher(String path) {
            this.path = path;
        }

        @Override
        public final boolean matches(Object item) {
            actual = item;
            return doMatch(item);
        }

        abstract boolean doMatch(Object item);

        Path getPath() {
            return Path.create(path, getPathPrefix(actual));
        }
    }

    private abstract static class AbstractJsonMatcher extends AbstractMatcher
            implements ConfigurableJsonMatcher {

        Configuration configuration = JsonAssert.getConfiguration();

        AbstractJsonMatcher(String path) {
            super(path);
        }

        @Override
        public ConfigurableJsonMatcher withTolerance(BigDecimal tolerance) {
            configuration = configuration.withTolerance(tolerance);
            return this;
        }

        @Override
        public ConfigurableJsonMatcher withTolerance(double tolerance) {
            configuration = configuration.withTolerance(tolerance);
            return this;
        }

        @Override
        public ConfigurableJsonMatcher when(Option first, Option... next) {
            configuration = configuration.withOptions(first, next);
            return this;
        }

        @Override
        public ConfigurableJsonMatcher withOptions(Collection options) {
            configuration = configuration.withOptions(options);
            return this;
        }

        @Override
        public final ConfigurableJsonMatcher when(PathsParam object, ApplicableForPath... actions) {
            configuration = configuration.when(object, actions);
            return this;
        }

        /**
         * Adds a matcher to be used in ${json-unit.matches:matcherName} macro.
         */
        @Override
        public ConfigurableJsonMatcher withMatcher(String matcherName, Matcher matcher) {
            configuration = configuration.withMatcher(matcherName, matcher);
            return this;
        }

        /**
         * Makes JsonUnit ignore the specified paths in the actual value. If the path matches,
         * it's completely ignored. It may be missing, null or have any value
         */
        @Override
        public ConfigurableJsonMatcher whenIgnoringPaths(String... paths) {
            configuration = configuration.whenIgnoringPaths(paths);
            return this;
        }

        @Override
        public ConfigurableJsonMatcher withDifferenceListener(DifferenceListener differenceListener) {
            configuration = configuration.withDifferenceListener(differenceListener);
            return this;
        }
    }

    private static final class JsonPartMatcher extends AbstractJsonMatcher {
        // IntelliJ integration is broken by default difference string. Hamcrest generates 'Expected:' and IntelliJ
        // searches for last 'but was:' and everything between is taken as expected value
        private static final String HAMCREST_DIFFERENCE_STRING = "expected <%s> but was <%s>";
        private final Object expected;

        // One matcher can be used to match multiple array items. We need to persist diff description between doMatch()
        // and
        // describeMismatch() method calls. While Hamcrest 1 called doMatch() and describeMismatch() one after each
        // other
        // Hamcrest 2 calls doMatch() multiple times followed by multiple calls of describeMismatch()
        // using IdentityHashMap since not all compared object do have to implement hashCode and equals
        private final Map differences = new IdentityHashMap<>();

        JsonPartMatcher(String path, Object expected) {
            super(path);
            this.expected = expected;
        }

        @Override
        boolean doMatch(Object item) {
            Diff diff = createInternal(
                    expected, item, FULL_JSON, Path.create(path, ""), configuration, HAMCREST_DIFFERENCE_STRING);
            if (!diff.similar()) {
                differences.put(item, diff.differences());
            }
            return diff.similar();
        }

        @Override
        public void describeTo(Description description) {
            if (EMPTY_PATH.equals(path)) {
                description.appendText(safeToString());
            } else {
                description
                        .appendText(safeToString())
                        .appendText(" in \"")
                        .appendText(path)
                        .appendText("\"");
            }
        }

        private String safeToString() {
            return expected != null ? expected.toString() : "null";
        }

        @Override
        public void describeMismatch(Object item, Description description) {
            description.appendText(getDifference(item));
        }

        private String getDifference(Object item) {
            if (differences.size() == 1) {
                // If there is only one difference, no need search the map.
                // Solves the case when the item is not the same instance as the one sent to match() #338
                return differences.values().iterator().next();
            } else {
                return differences.get(item);
            }
        }
    }

    private static final class JsonNodeAbsenceMatcher extends AbstractJsonMatcher {
        JsonNodeAbsenceMatcher(String path) {
            super(path);
        }

        @Override
        boolean doMatch(Object item) {
            return nodeAbsent(item, path, configuration);
        }

        @Override
        public void describeTo(Description description) {
            description.appendText("Node \"" + getPath() + "\" is absent.");
        }

        @Override
        public void describeMismatch(Object item, Description description) {
            description.appendText("Node \"" + getPath() + "\" is \"" + getNode(item, path) + "\".");
        }
    }

    private static final class JsonNodePresenceMatcher extends AbstractJsonMatcher {
        JsonNodePresenceMatcher(String path) {
            super(path);
        }

        @Override
        boolean doMatch(Object item) {
            return !nodeAbsent(item, getPath(), configuration);
        }

        @Override
        public void describeTo(Description description) {
            description.appendText("Node \"" + getPath() + "\" is present.");
        }

        @Override
        public void describeMismatch(Object item, Description description) {
            description.appendText("Node \"" + getPath() + "\" is missing.");
        }
    }

    private static final class MatcherApplyingMatcher extends AbstractMatcher {
        private final Matcher matcher;

        MatcherApplyingMatcher(String path, Matcher matcher) {
            super(path);
            this.matcher = matcher;
        }

        @Override
        boolean doMatch(Object item) {
            Node node = getNode(item, path);
            if (!node.isMissingNode()) {
                return matcher.matches(node.getValue());
            } else {
                // missing node does not match
                return false;
            }
        }

        @Override
        public void describeTo(Description description) {
            description.appendText("node \"" + getPath() + "\" ");
            matcher.describeTo(description);
        }

        @Override
        public void describeMismatch(Object item, Description description) {
            Node node = getNode(item, path);
            if (!node.isMissingNode()) {
                super.describeMismatch(node.getValue(), description);
            } else {
                description.appendText("Node \"" + getPath() + "\" is missing.");
            }
        }
    }
}