/*
* 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 org.skyscreamer.jsonassert;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.text.MessageFormat;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.junit.Test;
import org.skyscreamer.jsonassert.comparator.ArraySizeComparator;
import org.skyscreamer.jsonassert.comparator.CustomComparator;
import org.skyscreamer.jsonassert.comparator.DefaultComparator;
import org.skyscreamer.jsonassert.comparator.JSONComparator;
/**
* Unit tests for ArrayValueMatcher
*
* @author Duncan Mackinder
*
*/
public class ArrayValueMatcherTest {
private static final String ARRAY_OF_JSONOBJECTS = "{a:[{background:white,id:1,type:row},{background:grey,id:2,type:row},{background:white,id:3,type:row},{background:grey,id:4,type:row}]}";
private static final String ARRAY_OF_INTEGERS = "{a:[1,2,3,4,5]}";
private static final String ARRAY_OF_JSONARRAYS = "{a:[[6,7,8],[9,10,11],[12,13,14],[19,20,21,22]]}";
private static final JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
private void doTest(String jsonPath, ArrayValueMatcher<Object> arrayValueMatcher, String expectedJSON,
String actualJSON) throws JSONException {
Customization customization = new Customization(jsonPath, arrayValueMatcher);
JSONAssert.assertEquals(expectedJSON, actualJSON, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
private void doFailingMatchTest(String jsonPath, ArrayValueMatcher<Object> arrayValueMatcher, String expectedJSON, String actualJSON, String expectedMessagePattern) throws JSONException {
try {
doTest(jsonPath, arrayValueMatcher, expectedJSON, actualJSON);
}
catch (AssertionError e) {
String failureMessage = MessageFormat.format("Exception message ''{0}'', does not match expected pattern ''{1}''", e.getMessage(), expectedMessagePattern);
assertTrue(failureMessage, e.getMessage().matches(expectedMessagePattern));
return;
}
fail("AssertionError not thrown");
}
@Test
public void matchesSecondElementOfJSONObjectArray() throws JSONException {
doTest("a", new ArrayValueMatcher<Object>(comparator, 1), "{a:[{background:grey,id:2,type:row}]}", ARRAY_OF_JSONOBJECTS);
}
@Test
public void failsWhenSecondElementOfJSONObjectArrayDoesNotMatch() throws JSONException {
doFailingMatchTest("a",
new ArrayValueMatcher<Object>(comparator, 1),
"{a:[{background:DOES_NOT_MATCH,id:2,type:row}]}",
ARRAY_OF_JSONOBJECTS,
"a\\[1\\]\\.background\\s*Expected:\\s*DOES_NOT_MATCH\\s*got:\\s*grey\\s*");
}
@Test
public void failsWhenThirdElementOfJSONObjectArrayDoesNotMatchInMultiplePlaces() throws JSONException {
doFailingMatchTest("a",
new ArrayValueMatcher<Object>(comparator, 2),
"{a:[{background:DOES_NOT_MATCH,id:3,type:WRONG_TYPE}]}",
ARRAY_OF_JSONOBJECTS,
"a\\[2\\]\\.background\\s*Expected:\\s*DOES_NOT_MATCH\\s*got:\\s*white\\s*;\\s*a\\[2\\]\\.type\\s*Expected:\\s*WRONG_TYPE\\s*got:\\s*row\\s*");
}
@Test
public void failsWhenTwoElementsOfJSONObjectArrayDoNotMatch() throws JSONException {
doFailingMatchTest("a",
new ArrayValueMatcher<Object>(comparator, 1, 2),
"{a:[{background:DOES_NOT_MATCH,id:2,type:row},{background:white,id:3,type:WRONG_TYPE}]}",
ARRAY_OF_JSONOBJECTS,
"a\\[1\\]\\.background\\s*Expected:\\s*DOES_NOT_MATCH\\s*got:\\s*grey\\s*;\\s*a\\[2\\]\\.type\\s*Expected:\\s*WRONG_TYPE\\s*got:\\s*row\\s*");
}
@Test
public void matchesThirdElementOfSimpleValueArray() throws JSONException {
doTest("a", new ArrayValueMatcher<Object>(comparator, 2), "{a:[3]}", ARRAY_OF_INTEGERS);
}
@Test
public void failsWhenTwoElementOfSimpleValueArrayDoNotMatch() throws JSONException {
doFailingMatchTest("a", new ArrayValueMatcher<Object>(comparator, 3, 4), "{a:[3,4]}", ARRAY_OF_INTEGERS,
"a\\[3\\]\\s*Expected:\\s3\\s*got:\\s*4\\s*;\\s*a\\[4\\]\\s*Expected:\\s*4\\s*got:\\s*5\\s*");
}
@Test
public void matchesFirstElementOfArrayOfJSONArrays() throws JSONException {
doTest("a", new ArrayValueMatcher<Object>(comparator, 0), "{a:[[6,7,8]]}", ARRAY_OF_JSONARRAYS);
}
@Test
public void matchesSizeOfFirstThreeInnerArrays() throws JSONException {
JSONComparator innerArraySizeComparator = new ArraySizeComparator(JSONCompareMode.STRICT_ORDER);
doTest("a", new ArrayValueMatcher<Object>(innerArraySizeComparator, 0, 2), "{a:[[3]]}", ARRAY_OF_JSONARRAYS);
}
@Test
public void failsWhenInnerArraySizeDoesNotMatch() throws JSONException {
JSONComparator innerArraySizeComparator = new ArraySizeComparator(JSONCompareMode.STRICT_ORDER);
doFailingMatchTest("a",
new ArrayValueMatcher<Object>(innerArraySizeComparator),
"{a:[[3]]}",
ARRAY_OF_JSONARRAYS,
"a\\[3\\]\\[\\]\\s*Expected:\\s*array size of 3 elements\\s*got:\\s*4 elements\\s*");
}
@Test
public void failsWhenInnerJSONObjectArrayElementDoesNotMatch() throws JSONException {
ArrayValueMatcher<Object> innerArrayValueMatcher = new ArrayValueMatcher<Object>(comparator, 1);
JSONComparator innerArrayComparator = new CustomComparator(
JSONCompareMode.LENIENT, new Customization("a[2]", innerArrayValueMatcher));
doFailingMatchTest("a",
new ArrayValueMatcher<Object>(innerArrayComparator, 2), // tests inner array i.e. [12,13,14]
"{a:[[99]]}",
ARRAY_OF_JSONARRAYS,
"a\\[2\\]\\[1\\]\\s*Expected:\\s*99\\s*got:\\s*13\\s*");
}
@Test
public void matchesEveryElementOfJSONObjectArray() throws JSONException {
doTest("a", new ArrayValueMatcher<Object>(comparator), "{a:[{type:row}]}", ARRAY_OF_JSONOBJECTS);
}
@Test
public void failsWhenNotEveryElementOfJSONObjectArrayMatches() throws JSONException {
doFailingMatchTest("a",
new ArrayValueMatcher<Object>(comparator),
"{a:[{background:white}]}",
ARRAY_OF_JSONOBJECTS,
"a\\[1\\]\\.background\\s*Expected:\\s*white\\s*got:\\s*grey\\s*;\\s*a\\[3\\]\\.background\\s*Expected:\\s*white\\s*got:\\s*grey\\s*");
}
@Test
public void matchesEveryElementOfJSONObjectArrayWhenRangeTooLarge() throws JSONException {
doTest("a", new ArrayValueMatcher<Object>(comparator, 0, 500), "{a:[{type:row}]}", ARRAY_OF_JSONOBJECTS);
}
@Test
public void matchesElementPairsStartingFromElement1OfJSONObjectArrayWhenRangeTooLarge() throws JSONException {
doTest("a", new ArrayValueMatcher<Object>(comparator, 1, 500), "{a:[{background:grey},{background:white}]}", ARRAY_OF_JSONOBJECTS);
}
@Test
public void matchesElementPairsStartingFromElement0OfJSONObjectArrayWhenRangeTooLarge() throws JSONException {
doTest("a", new ArrayValueMatcher<Object>(comparator), "{a:[{background:white},{background:grey}]}", ARRAY_OF_JSONOBJECTS);
}
@Test
public void failsWhenAppliedToNonArray() throws JSONException {
try {
doTest("a", new ArrayValueMatcher<Object>(comparator), "{a:[{background:white}]}", "{a:{attr1:value1,attr2:value2}}");
}
catch (IllegalArgumentException e) {
assertEquals("Exception message", "ArrayValueMatcher applied to non-array actual value", e.getMessage());
return;
}
fail("Did not throw IllegalArgumentException");
}
/*
* Following tests verify the ability to match an element containing either
* a simple value or a JSON object against simple value or JSON object
* without requiring expected value to be wrapped in an array reducing
* slightly the syntactic load on teh test author & reader.
*/
@Test
public void simpleValueMatchesSecondElementOfJSONObjectArray() throws JSONException {
doTest("a", new ArrayValueMatcher<Object>(comparator, 3), "{a:4}", ARRAY_OF_INTEGERS);
}
@Test
public void jsonObjectMatchesSecondElementOfJSONObjectArray() throws JSONException {
doTest("a", new ArrayValueMatcher<Object>(comparator, 1), "{a:{background:grey,id:2,type:row}}", ARRAY_OF_JSONOBJECTS);
}
/*
* Following tests contain copies of code quoted in ArrayValueMatcher JavaDoc and are included to verify that the exact code documented works as expected.
*/
@Test
public void verifyIdAttributeOfFirstArrayElementMatches() throws JSONException {
JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
Customization customization = new Customization("a", new ArrayValueMatcher<Object>(comparator, 0));
JSONAssert.assertEquals("{a:[{id:1}]}", ARRAY_OF_JSONOBJECTS, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
@Test
public void verifyIdAttributeOfFirstArrayElementMatchesSimplifiedExpectedSyntax() throws JSONException {
JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
Customization customization = new Customization("a", new ArrayValueMatcher<Object>(comparator, 0));
JSONAssert.assertEquals("{a:{id:1}}", ARRAY_OF_JSONOBJECTS, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
@Test
public void verifyTypeAttributeOfSecondAndThirdElementMatchesRow() throws JSONException {
JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
Customization customization = new Customization("a", new ArrayValueMatcher<Object>(comparator, 1, 2));
JSONAssert.assertEquals("{a:[{type:row}]}", ARRAY_OF_JSONOBJECTS, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
@Test
public void verifyTypeAttributeOfEveryArrayElementMatchesRow() throws JSONException {
JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
Customization customization = new Customization("a", new ArrayValueMatcher<Object>(comparator));
JSONAssert.assertEquals("{a:[{type:row}]}", ARRAY_OF_JSONOBJECTS, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
@Test
public void verifyEveryArrayElementWithCustomComparator() throws JSONException {
// get length of array we will verify
int aLength = ((JSONArray)((JSONObject)JSONParser.parseJSON(ARRAY_OF_JSONOBJECTS)).get("a")).length();
// create array of customizations one for each array element
RegularExpressionValueMatcher<Object> regExValueMatcher = new RegularExpressionValueMatcher<Object>("\\d+"); // matches one or more digits
Customization[] customizations = new Customization[aLength];
for (int i=0; i<aLength; i++) {
String contextPath = "a["+i+"].id";
customizations[i] = new Customization(contextPath, regExValueMatcher);
}
CustomComparator regExComparator = new CustomComparator(JSONCompareMode.STRICT_ORDER, customizations);
ArrayValueMatcher<Object> regExArrayValueMatcher = new ArrayValueMatcher<Object>(regExComparator);
Customization regExArrayValueCustomization = new Customization("a", regExArrayValueMatcher);
CustomComparator regExCustomArrayValueComparator = new CustomComparator(JSONCompareMode.STRICT_ORDER, new Customization[] { regExArrayValueCustomization });
JSONAssert.assertEquals("{a:[{id:X}]}", ARRAY_OF_JSONOBJECTS, regExCustomArrayValueComparator);
}
@Test
public void verifyBackgroundAttributesOfEveryArrayElementAlternateBetweenWhiteAndGrey() throws JSONException {
JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
Customization customization = new Customization("a", new ArrayValueMatcher<Object>(comparator));
JSONAssert.assertEquals("{a:[{background:white},{background:grey}]}", ARRAY_OF_JSONOBJECTS, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
@Test
public void verifyEveryElementOfArrayIsJSONArrayOfLength3() throws JSONException {
JSONComparator comparator = new ArraySizeComparator(JSONCompareMode.STRICT_ORDER);
Customization customization = new Customization("a", new ArrayValueMatcher<Object>(comparator, 0, 2));
JSONAssert.assertEquals("{a:[[3]]}", ARRAY_OF_JSONARRAYS, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
@Test
public void verifySecondElementOfArrayIsJSONArrayWhoseFirstElementIs9() throws JSONException {
Customization innerCustomization = new Customization("a[1]", new ArrayValueMatcher<Object>(comparator, 0));
JSONComparator comparator = new CustomComparator(JSONCompareMode.LENIENT, innerCustomization);
Customization customization = new Customization("a", new ArrayValueMatcher<Object>(comparator, 1));
JSONAssert.assertEquals("{a:[[9]]}", ARRAY_OF_JSONARRAYS, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
@Test
public void verifySecondElementOfArrayIsJSONArrayWhoseFirstElementIs9WithSimpliedExpectedString() throws JSONException {
Customization innerCustomization = new Customization("a[1]", new ArrayValueMatcher<Object>(comparator, 0));
JSONComparator comparator = new CustomComparator(JSONCompareMode.LENIENT, innerCustomization);
Customization customization = new Customization("a", new ArrayValueMatcher<Object>(comparator, 1));
JSONAssert.assertEquals("{a:[9]}", ARRAY_OF_JSONARRAYS, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
@Test
public void verifySecondElementOfArrayIsJSONArrayWhoseFirstElementIs9WithEvenMoreSimpliedExpectedString() throws JSONException {
Customization innerCustomization = new Customization("a[1]", new ArrayValueMatcher<Object>(comparator, 0));
JSONComparator comparator = new CustomComparator(JSONCompareMode.LENIENT, innerCustomization);
Customization customization = new Customization("a", new ArrayValueMatcher<Object>(comparator, 1));
JSONAssert.assertEquals("{a:9}", ARRAY_OF_JSONARRAYS, new CustomComparator(JSONCompareMode.LENIENT, customization));
}
}