Mapping improvements.

changelog.md

@@ -13,12 +13,14 @@ In The Pipe
 * Support regex in inline filters (ruby syntax)
   `parse(JSON_DOCUMENT).read("$.store.book[?(@.category =~ /reference/)].author")`
   `parse(JSON_DOCUMENT).read("$.store.book[?(@.category =~ /REFERENCE/i)].author")`
-* Inline filter does not force path first  
+* Inline filter does not require path statement on left side of operator  
   `parse(JSON_DOCUMENT).read("$.store.book[?(@.category == 'reference')].author")`    
   `parse(JSON_DOCUMENT).read("$.store.book[?('reference' == @.category)].author")`    
 * Negate exist checks in inline filters (not defined or null) 
   `parse(JSON_DOCUMENT).read("$.store.book[?(!@.isbn)]")`    
-
+* Improved object mapping with Jackson and Gson (now handles generic types)
+* Exceptions thrown by JsonPath.compile are now wrapped in an InvalidPathException
+* Fixed Deep scanning issue (#60) 
 
 1.1.0 (2014-10-01)
 ==================

json-path/src/main/java/com/jayway/jsonpath/ReadContext.java

@@ -70,6 +70,36 @@ public interface ReadContext {
      */
     <T> T read(JsonPath path, Class<T> type);
 
+    /**
+     * Reads the given path from this context
+     *
+     * Sample code to create a TypeRef
+     * <code>
+     *       TypeRef ref = new TypeRef<List<Integer>>() {};
+     * </code>
+     *
+     * @param path path to apply
+     * @param typeRef  expected return type (will try to map)
+     * @param <T>
+     * @return result
+     */
+    <T> T read(JsonPath path, TypeRef<T> typeRef);
+
+    /**
+     * Reads the given path from this context
+     *
+     * Sample code to create a TypeRef
+     * <code>
+     *       TypeRef ref = new TypeRef<List<Integer>>() {};
+     * </code>
+     *
+     * @param path path to apply
+     * @param typeRef  expected return type (will try to map)
+     * @param <T>
+     * @return result
+     */
+    <T> T read(String path, TypeRef<T> typeRef);
+
     /**
      * Stops evaluation when maxResults limit has been reached
      * @param maxResults

json-path/src/main/java/com/jayway/jsonpath/TypeRef.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2011 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 com.jayway.jsonpath;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+
+/**
+ * Used to specify generic type information in {@link com.jayway.jsonpath.ReadContext}
+ *
+ * <code>
+ *       TypeRef ref = new TypeRef<List<Integer>>() { };
+ * </code>
+ *
+ * @param <T>
+ */
+public abstract class TypeRef<T> implements Comparable<TypeRef<T>> {
+    protected final Type type;
+    
+    protected TypeRef()
+    {
+        Type superClass = getClass().getGenericSuperclass();
+        if (superClass instanceof Class<?>) {
+            throw new IllegalArgumentException("No type info in TypeRef");
+        }
+        type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
+    }
+
+    public Type getType() { return type; }
+    
+    /**
+     * The only reason we define this method (and require implementation
+     * of <code>Comparable</code>) is to prevent constructing a
+     * reference without type information.
+     */
+    @Override
+    public int compareTo(TypeRef<T> o) {
+        return 0;
+    }
+}
+

json-path/src/main/java/com/jayway/jsonpath/internal/JsonReader.java

@@ -21,6 +21,7 @@ import com.jayway.jsonpath.JsonPath;
 import com.jayway.jsonpath.ParseContext;
 import com.jayway.jsonpath.Predicate;
 import com.jayway.jsonpath.ReadContext;
+import com.jayway.jsonpath.TypeRef;
 import com.jayway.jsonpath.spi.http.HttpProviderFactory;
 
 import java.io.File;
@@ -147,6 +148,16 @@ public class JsonReader implements ParseContext, DocumentContext {
         return convert(read(path), type, configuration);
     }
 
+    @Override
+    public <T> T read(JsonPath path, TypeRef<T> type) {
+        return convert(read(path), type, configuration);
+    }
+
+    @Override
+    public <T> T read(String path, TypeRef<T> type) {
+        return convert(read(path), type, configuration);
+    }
+
     public ReadContext limit(int maxResults){
         return withListeners(new LimitingEvaluationListener(maxResults));
     }
@@ -160,6 +171,10 @@ public class JsonReader implements ParseContext, DocumentContext {
         return configuration.mappingProvider().map(obj, targetType, configuration);
     }
 
+    private <T> T convert(Object obj, TypeRef<T> targetType, Configuration configuration){
+        return configuration.mappingProvider().map(obj, targetType, configuration);
+    }
+
     @Override
     public DocumentContext set(String path, Object newValue, Predicate... filters) {
         return set(compile(path, filters), newValue);

json-path/src/main/java/com/jayway/jsonpath/internal/PathCompiler.java

@@ -51,10 +51,12 @@ public class PathCompiler {
 
 
     public static Path compile(String path, Predicate... filters) {
+
         notEmpty(path, "Path may not be null empty");
+        try {
             path = path.trim();
 
-        if(path.endsWith("..")){
+            if (path.endsWith("..")) {
                 throw new InvalidPathException("A path can not end with a scan.");
             }
 
@@ -66,20 +68,20 @@ public class PathCompiler {
 
             boolean isRootPath = (path.charAt(0) == '$');
 
-        if(path.charAt(0) == '@'){
+            if (path.charAt(0) == '@') {
                 path = "$" + path.substring(1);
             }
 
-        if(path.length() > 1 &&
+            if (path.length() > 1 &&
                     path.charAt(1) != '.' &&
-           path.charAt(1) != '['){
+                    path.charAt(1) != '[') {
                 throw new InvalidPathException("Invalid path " + path);
             }
 
             String cacheKey = path + isRootPath + filterList.toString();
             Path p = cache.get(cacheKey);
             if (p != null) {
-            if(logger.isDebugEnabled()) logger.debug("Using cached path: " + cacheKey);
+                if (logger.isDebugEnabled()) logger.debug("Using cached path: " + cacheKey);
                 return p;
             }
 
@@ -150,6 +152,10 @@ public class PathCompiler {
             cache.put(cacheKey, pa);
 
             return pa;
+
+        } catch (Exception ex){
+            throw new InvalidPathException(ex);
+        }
     }
 
     private static void assertValidFieldChars(String s, int start, int positions) {

json-path/src/main/java/com/jayway/jsonpath/internal/spi/mapper/GsonMappingProvider.java

@@ -16,8 +16,12 @@ package com.jayway.jsonpath.internal.spi.mapper;
 
 import com.google.gson.Gson;
 import com.google.gson.JsonElement;
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.reflect.TypeToken;
 import com.jayway.jsonpath.Configuration;
 import com.jayway.jsonpath.JsonPathException;
+import com.jayway.jsonpath.TypeRef;
+import com.jayway.jsonpath.spi.mapper.MappingException;
 import com.jayway.jsonpath.spi.mapper.MappingProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -59,6 +63,19 @@ public class GsonMappingProvider implements MappingProvider {
 
     @Override
     public <T> T map(Object source, Class<T> targetType, Configuration configuration) {
+        try {
             return factory.createInstance().getAdapter(targetType).fromJsonTree((JsonElement) source);
+        } catch (Exception e){
+            throw new MappingException(e);
+        }
+    }
+
+    @Override
+    public <T> T map(Object source, TypeRef<T> targetType, Configuration configuration) {
+        try {
+            return (T) factory.createInstance().getAdapter(TypeToken.get(targetType.getType())).fromJsonTree((JsonElement) source);
+        } catch (Exception e){
+            throw new MappingException(e);
+        }
     }
 }

json-path/src/main/java/com/jayway/jsonpath/internal/spi/mapper/JacksonMappingProvider.java

@@ -14,15 +14,17 @@
  */
 package com.jayway.jsonpath.internal.spi.mapper;
 
+import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.jayway.jsonpath.Configuration;
+import com.jayway.jsonpath.TypeRef;
+import com.jayway.jsonpath.spi.mapper.MappingException;
 import com.jayway.jsonpath.spi.mapper.MappingProvider;
 
 public class JacksonMappingProvider implements MappingProvider {
 
     private final ObjectMapper objectMapper;
 
-
     public JacksonMappingProvider() {
         this(new ObjectMapper());
     }
@@ -32,12 +34,31 @@ public class JacksonMappingProvider implements MappingProvider {
     }
 
 
-
     @Override
     public <T> T map(Object source, Class<T> targetType, Configuration configuration) {
         if(source == null){
             return null;
         }
+        try {
             return objectMapper.convertValue(source, targetType);
+        } catch (Exception e) {
+            throw new MappingException(e);
+        }
+
+    }
+
+    @Override
+    public <T> T map(Object source, final TypeRef<T> targetType, Configuration configuration) {
+        if(source == null){
+            return null;
+        }
+        JavaType type = objectMapper.getTypeFactory().constructType(targetType.getType());
+
+        try {
+            return (T)objectMapper.convertValue(source, type);
+        } catch (Exception e) {
+            throw new MappingException(e);
+        }
+
     }
 }

json-path/src/main/java/com/jayway/jsonpath/internal/spi/mapper/JsonSmartMappingProvider.java

@@ -15,17 +15,24 @@
 package com.jayway.jsonpath.internal.spi.mapper;
 
 import com.jayway.jsonpath.Configuration;
+import com.jayway.jsonpath.TypeRef;
 import com.jayway.jsonpath.spi.mapper.MappingException;
 import com.jayway.jsonpath.spi.mapper.MappingProvider;
+import net.minidev.json.JSONUtil;
+import net.minidev.json.JSONValue;
 import net.minidev.json.writer.JsonReader;
 import net.minidev.json.writer.JsonReaderI;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.math.BigDecimal;
 import java.text.DateFormat;
 import java.text.ParseException;
+import java.util.Collection;
 import java.util.Date;
+import java.util.Map;
 
 public class JsonSmartMappingProvider implements MappingProvider {
 
@@ -73,8 +80,22 @@ public class JsonSmartMappingProvider implements MappingProvider {
         if (targetType.isAssignableFrom(source.getClass())) {
             return (T) source;
         }
+        try {
+            if(!configuration.jsonProvider().isMap(source) && !configuration.jsonProvider().isArray(source)){
                 return factory.createInstance().getMapper(targetType).convert(source);
             }
+            String s = configuration.jsonProvider().toJson(source);
+            return (T) JSONValue.parse(s, targetType);
+        } catch (Exception e) {
+            throw new MappingException(e);
+        }
+
+    }
+
+    @Override
+    public <T> T map(Object source, TypeRef<T> targetType, Configuration configuration) {
+        throw new UnsupportedOperationException("Not supported! Use Jackson or Gson provider");
+    }
 
     private static class StringReader extends JsonReaderI<String> {
         public StringReader() {

json-path/src/main/java/com/jayway/jsonpath/spi/mapper/MappingProvider.java

@@ -15,6 +15,7 @@
 package com.jayway.jsonpath.spi.mapper;
 
 import com.jayway.jsonpath.Configuration;
+import com.jayway.jsonpath.TypeRef;
 
 /**
  * Maps object between different Types
@@ -31,4 +32,14 @@ public interface MappingProvider {
      * @return return the mapped object
      */
     <T> T map(Object source, Class<T> targetType, Configuration configuration);
+
+    /**
+     *
+     * @param source object to map
+     * @param targetType the type the source object should be mapped to
+     * @param configuration current configuration
+     * @param <T> the mapped result type
+     * @return return the mapped object
+     */
+    <T> T map(Object source, TypeRef<T> targetType, Configuration configuration);
 }

json-path/src/test/java/com/jayway/jsonpath/GsonJsonProviderTest.java

@@ -3,13 +3,40 @@ package com.jayway.jsonpath;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import com.jayway.jsonpath.spi.mapper.MappingException;
 import org.junit.Test;
 
+import java.io.IOException;
+import java.util.List;
+
 import static com.jayway.jsonpath.JsonPath.using;
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class GsonJsonProviderTest extends BaseTest {
 
+    private static final String JSON =
+            "[" +
+            "{\n" +
+            "   \"foo\" : \"foo0\",\n" +
+            "   \"bar\" : 0,\n" +
+            "   \"baz\" : true,\n" +
+            "   \"gen\" : {\"eric\" : \"yepp\"}" +
+            "}," +
+            "{\n" +
+            "   \"foo\" : \"foo1\",\n" +
+            "   \"bar\" : 1,\n" +
+            "   \"baz\" : true,\n" +
+            "   \"gen\" : {\"eric\" : \"yepp\"}" +
+            "}," +
+            "{\n" +
+            "   \"foo\" : \"foo2\",\n" +
+            "   \"bar\" : 2,\n" +
+            "   \"baz\" : true,\n" +
+            "   \"gen\" : {\"eric\" : \"yepp\"}" +
+            "}" +
+            "]";
+
     @Test
     public void json_can_be_parsed() {
         JsonObject node =  using(GSON_CONFIGURATION).parse(JSON_DOCUMENT).read("$");
@@ -28,7 +55,7 @@ public class GsonJsonProviderTest extends BaseTest {
     @Test
     public void ints_are_unwrapped() {
         JsonElement node =  using(GSON_CONFIGURATION).parse(JSON_DOCUMENT).read("$.int-max-property");
-        int unwrapped =  using(GSON_CONFIGURATION).parse(JSON_DOCUMENT).read("$.int-max-property", Integer.class);
+        int unwrapped =  using(GSON_CONFIGURATION).parse(JSON_DOCUMENT).read("$.int-max-property", int.class);
 
         assertThat(unwrapped).isEqualTo(Integer.MAX_VALUE);
         assertThat(unwrapped).isEqualTo(node.getAsInt());
@@ -71,19 +98,49 @@ public class GsonJsonProviderTest extends BaseTest {
                 "}";
 
 
-        FooBarBaz fooBarBaz = JsonPath.using(GSON_CONFIGURATION).parse(json).read("$", FooBarBaz.class);
+        TestClazz testClazz = JsonPath.using(GSON_CONFIGURATION).parse(json).read("$", TestClazz.class);
+
+        assertThat(testClazz.foo).isEqualTo("foo");
+        assertThat(testClazz.bar).isEqualTo(10L);
+        assertThat(testClazz.baz).isEqualTo(true);
+
+    }
+
+    @Test
+    public void test_type_ref() throws IOException {
+        TypeRef<List<FooBarBaz<Gen>>> typeRef = new TypeRef<List<FooBarBaz<Gen>>>() {};
+
+        List<FooBarBaz<Gen>> list = JsonPath.using(GSON_CONFIGURATION).parse(JSON).read("$", typeRef);
+
+        assertThat(list.get(0).gen.eric).isEqualTo("yepp");
+    }
+
+    @Test(expected = MappingException.class)
+    public void test_type_ref_fail() throws IOException {
+        TypeRef<List<FooBarBaz<Integer>>> typeRef = new TypeRef<List<FooBarBaz<Integer>>>() {};
+
+        using(GSON_CONFIGURATION).parse(JSON).read("$", typeRef);
+    }
+
+    public static class FooBarBaz<T> {
+        public T gen;
+        public String foo;
+        public Long bar;
+        public boolean baz;
+    }
 
-        assertThat(fooBarBaz.foo).isEqualTo("foo");
-        assertThat(fooBarBaz.bar).isEqualTo(10L);
-        assertThat(fooBarBaz.baz).isEqualTo(true);
 
+    public static class Gen {
+        public String eric;
     }
 
-    public static class FooBarBaz {
+    public static class TestClazz {
         public String foo;
         public Long bar;
         public boolean baz;
     }
 
 
+
+
 }

json-path/src/test/java/com/jayway/jsonpath/JacksonTreeJsonProviderTest.java

@@ -3,13 +3,39 @@ package com.jayway.jsonpath;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.jayway.jsonpath.spi.mapper.MappingException;
 import org.junit.Test;
 
+import java.io.IOException;
+import java.util.List;
+
 import static com.jayway.jsonpath.JsonPath.using;
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class JacksonTreeJsonProviderTest extends BaseTest {
 
+    private static final String JSON =
+            "[" +
+            "{\n" +
+            "   \"foo\" : \"foo0\",\n" +
+            "   \"bar\" : 0,\n" +
+            "   \"baz\" : true,\n" +
+            "   \"gen\" : {\"eric\" : \"yepp\"}" +
+            "}," +
+            "{\n" +
+            "   \"foo\" : \"foo1\",\n" +
+            "   \"bar\" : 1,\n" +
+            "   \"baz\" : true,\n" +
+            "   \"gen\" : {\"eric\" : \"yepp\"}" +
+            "}," +
+            "{\n" +
+            "   \"foo\" : \"foo2\",\n" +
+            "   \"bar\" : 2,\n" +
+            "   \"baz\" : true,\n" +
+            "   \"gen\" : {\"eric\" : \"yepp\"}" +
+            "}" +
+            "]";
+
     @Test
     public void json_can_be_parsed() {
         ObjectNode node = using(JACKSON_TREE_CONFIGURATION).parse(JSON_DOCUMENT).read("$");
@@ -46,11 +72,35 @@ public class JacksonTreeJsonProviderTest extends BaseTest {
     @Test
     public void list_of_numbers() {
         ArrayNode objs = using(JACKSON_TREE_CONFIGURATION).parse(JSON_DOCUMENT).read("$.store.book[*].display-price");
+        System.out.println(objs.toString());
+    }
 
+    @Test
+    public void test_type_ref() throws IOException {
+        TypeRef<List<FooBarBaz<Gen>>> typeRef = new TypeRef<List<FooBarBaz<Gen>>>() {};
 
-        System.out.println(objs.toString());
+        List<FooBarBaz<Gen>> list = using(JACKSON_TREE_CONFIGURATION).parse(JSON).read("$", typeRef);
 
+        assertThat(list.get(0).gen.eric).isEqualTo("yepp");
     }
 
+    @Test(expected = MappingException.class)
+    public void test_type_ref_fail() throws IOException {
+        TypeRef<List<FooBarBaz<Integer>>> typeRef = new TypeRef<List<FooBarBaz<Integer>>>() {};
+
+        using(JACKSON_TREE_CONFIGURATION).parse(JSON).read("$", typeRef);
+    }
+
+    public static class FooBarBaz<T> {
+        public T gen;
+        public String foo;
+        public Long bar;
+        public boolean baz;
+    }
+
+
+    public static class Gen {
+        public String eric;
+    }
 
 }

json-path/src/test/java/com/jayway/jsonpath/JsonSmartMappingProviderTest.java

@@ -0,0 +1,69 @@
+package com.jayway.jsonpath;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+import static com.jayway.jsonpath.JsonPath.parse;
+import static com.jayway.jsonpath.JsonPath.using;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JsonSmartMappingProviderTest {
+
+    private static final String JSON =
+            "[" +
+                    "{\n" +
+                    "   \"foo\" : \"foo0\",\n" +
+                    "   \"bar\" : 0,\n" +
+                    "   \"baz\" : true,\n" +
+                    "   \"gen\" : {\"eric\" : \"yepp\"}" +
+                    "}," +
+                    "{\n" +
+                    "   \"foo\" : \"foo1\",\n" +
+                    "   \"bar\" : 1,\n" +
+                    "   \"baz\" : true,\n" +
+                    "   \"gen\" : {\"eric\" : \"yepp\"}" +
+                    "}," +
+                    "{\n" +
+                    "   \"foo\" : \"foo2\",\n" +
+                    "   \"bar\" : 2,\n" +
+                    "   \"baz\" : true,\n" +
+                    "   \"gen\" : {\"eric\" : \"yepp\"}" +
+                    "}" +
+                    "]";
+
+    @Test
+    public void class_mapping() {
+
+        Object map = Configuration.defaultConfiguration().jsonProvider().createMap();
+        Configuration.defaultConfiguration().jsonProvider().setProperty(map, "eric", "eric-val");
+
+
+        Gen gen = parse(map).read("$", Gen.class);
+
+        assertThat(gen.eric).isEqualTo("eric-val");
+
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void test_type_ref() throws IOException {
+
+        TypeRef<List<FooBarBaz>> typeRef = new TypeRef<List<FooBarBaz>>() {};
+
+        List gen = parse(JSON).read("$", typeRef);
+    }
+
+
+    public static class FooBarBaz {
+        public Gen gen;
+        public String foo;
+        public Long bar;
+        public boolean baz;
+    }
+
+
+    public static class Gen {
+        public String eric;
+    }
+}

json-path/src/test/java/com/jayway/jsonpath/old/IssuesTest.java

@@ -442,4 +442,59 @@ public class IssuesTest {
         Assertions.assertThat(result).containsExactly("foo");
 
     }
+
+    @Test
+    public void issue_60() {
+
+
+        String json ="[\n" +
+                "{\n" +
+                "  \"mpTransactionId\": \"542986eae4b001fd500fdc5b-coreDisc_50-title\",\n" +
+                "  \"resultType\": \"FAIL\",\n" +
+                "  \"narratives\": [\n" +
+                "    {\n" +
+                "      \"ruleProcessingDate\": \"Nov 2, 2014 7:30:20 AM\",\n" +
+                "      \"area\": \"Discovery\",\n" +
+                "      \"phase\": \"Validation\",\n" +
+                "      \"message\": \"Chain does not have a discovery event. Possible it was cut by the date that was picked\",\n" +
+                "      \"ruleName\": \"Validate chain\\u0027s discovery event existence\",\n" +
+                "      \"lastRule\": true\n" +
+                "    }\n" +
+                "  ]\n" +
+                "},\n" +
+                "{\n" +
+                "  \"mpTransactionId\": \"54298649e4b001fd500fda3e-fixCoreDiscovery_3-title\",\n" +
+                "  \"resultType\": \"FAIL\",\n" +
+                "  \"narratives\": [\n" +
+                "    {\n" +
+                "      \"ruleProcessingDate\": \"Nov 2, 2014 7:30:20 AM\",\n" +
+                "      \"area\": \"Discovery\",\n" +
+                "      \"phase\": \"Validation\",\n" +
+                "      \"message\": \"There is one and only discovery event ContentDiscoveredEvent(230) found.\",\n" +
+                "      \"ruleName\": \"Marks existence of discovery event (230)\",\n" +
+                "      \"lastRule\": false\n" +
+                "    },\n" +
+                "    {\n" +
+                "      \"ruleProcessingDate\": \"Nov 2, 2014 7:30:20 AM\",\n" +
+                "      \"area\": \"Discovery/Processing\",\n" +
+                "      \"phase\": \"Validation\",\n" +
+                "      \"message\": \"Chain does not have SLA start event (204) in Discovery or Processing. \",\n" +
+                "      \"ruleName\": \"Check if SLA start event is not present (204). \",\n" +
+                "      \"lastRule\": false\n" +
+                "    },\n" +
+                "    {\n" +
+                "      \"ruleProcessingDate\": \"Nov 2, 2014 7:30:20 AM\",\n" +
+                "      \"area\": \"Processing\",\n" +
+                "      \"phase\": \"Transcode\",\n" +
+                "      \"message\": \"No start transcoding events found\",\n" +
+                "      \"ruleName\": \"Start transcoding events missing (240)\",\n" +
+                "      \"lastRule\": true\n" +
+                "    }\n" +
+                "  ]\n" +
+                "}]";
+
+        List<String> problems = JsonPath.read(json, "$..narratives[?(@.lastRule==true)].message");
+
+        Assertions.assertThat(problems).containsExactly("Chain does not have a discovery event. Possible it was cut by the date that was picked", "No start transcoding events found");
+    }
 }