com.jayway.jsonpath.InvalidJsonException Java Examples

private boolean isJsonElementSearchCompleted(HttpResponse response, String jsonPath)
{
    if (response == null)
    {
        return true;
    }
    String responseBody = response.getResponseBodyAsString();
    try
    {
        // Empty response may be in case of HTTP "204 NO CONTENT"
        return StringUtils.isNotEmpty(responseBody) && getElementsNumber(responseBody, jsonPath) > 0;
    }
    catch (InvalidJsonException ignored)
    {
        return false;
    }
}
 

static DocumentContext validateAndEstablishJsonContext(ProcessSession processSession, FlowFile flowFile) {
    // Parse the document once into an associated context to support multiple path evaluations if specified
    final AtomicReference<DocumentContext> contextHolder = new AtomicReference<>(null);
    processSession.read(flowFile, new InputStreamCallback() {
        @Override
        public void process(InputStream in) throws IOException {
            try (BufferedInputStream bufferedInputStream = new BufferedInputStream(in)) {
                DocumentContext ctx = JsonPath.using(STRICT_PROVIDER_CONFIGURATION).parse(bufferedInputStream);
                contextHolder.set(ctx);
            } catch (IllegalArgumentException iae) {
                // The JsonPath.parse() above first parses the json, then creates a context object from the parsed
                // json.  It is possible for the json parsing to complete without error, but produce a null object.
                // In this case the context creation will fail and throw an IllegalArgumentException.  This is in
                // my opinion a bug in the JsonPath library, as it doesn't really throw the correct exception
                // contextually.
                // The general handling in derived classes handles InvalidJsonException.
                // The best thing to do here, is to re-throw with the proper exception, such that the calling logic
                // can route.
                throw new InvalidJsonException(iae);
            }
        }
    });

    return contextHolder.get();
}
 

@Override
public Object parse(String string) {
    try {
        return jsonProvider.parse(string);
    } catch (InvalidJsonException e) {
        // Jackson refuses to parse primitive types
        return asPrimitiveValue(string);
    }
}
 

@Test public void testDejsonize() {
  assertDejsonize("{}",
      is(Collections.emptyMap()));
  assertDejsonize("[]",
      is(Collections.emptyList()));

  // expect exception thrown
  final String message = "com.fasterxml.jackson.core.JsonParseException: "
      + "Unexpected close marker '}': expected ']' (for Array starting at "
      + "[Source: (String)\"[}\"; line: 1, column: 1])\n at [Source: "
      + "(String)\"[}\"; line: 1, column: 3]";
  assertDejsonizeFailed("[}",
      errorMatches(new InvalidJsonException(message)));
}
 

@Test
public void testAssigningRawTextWhichOtherwiseConfusesKarate() {
    ScenarioContext ctx = getContext();
    try {
        Script.assign("foo", "{ not json }", ctx);
        fail("we expected this to fail");
    } catch (InvalidJsonException e) {
        logger.debug("expected {}", e.getMessage());
    }
    Script.assign(AssignType.TEXT, "foo", "{ not json }", ctx, true);
    assertTrue(Script.matchNamed(MatchType.EQUALS, "foo", null, "'{ not json }'", ctx).pass);
}
 

@Override
public Object parse(String json) throws InvalidJsonException {
  try {
    return mapper.readValue(json, Object.class);
  } catch (IOException e) {
    throw new InvalidJsonException(e.getMessage(), e);
  }
}
 

@Override
public Object parse(InputStream jsonStream, String charset) throws InvalidJsonException {
  try {
    return mapper.readValue(new InputStreamReader(jsonStream, charset), Object.class);
  } catch (IOException e) {
    throw new IllegalStateException(e);
  }
}
 

@Test void testDejsonize() {
  assertDejsonize("{}",
      is(Collections.emptyMap()));
  assertDejsonize("[]",
      is(Collections.emptyList()));

  // expect exception thrown
  final String message = "com.fasterxml.jackson.core.JsonParseException: "
      + "Unexpected close marker '}': expected ']' (for Array starting at "
      + "[Source: (String)\"[}\"; line: 1, column: 1])\n at [Source: "
      + "(String)\"[}\"; line: 1, column: 3]";
  assertDejsonizeFailed("[}",
      errorMatches(new InvalidJsonException(message)));
}
 

protected DocumentContext getDocumentContext(EvaluationContext context) {
    final String subjectValue = subject.evaluate(context).getValue();
    if (subjectValue == null || subjectValue.length() == 0) {
        throw new AttributeExpressionLanguageException("Subject is empty");
    }
    DocumentContext documentContext = null;
    try {
        documentContext = validateAndEstablishJsonContext(subjectValue);
    } catch (InvalidJsonException e) {
        throw new AttributeExpressionLanguageException("Subject contains invalid JSON: " + subjectValue, e);
    }
    return documentContext;
}
 

@Override
public void measure(JsonPathCache cache)
      throws InvalidJsonException {
  valid = true;
  resultMap = new FieldCounter<>();
  duplumKeyMap = null;
  recordId = null;
  leader = null;
  x007 = null;
  x008 = null;
  titleWords = null;
  authorWords = null;
  duplumKeyType = null;
  dateOfPublication = null;
  isbn = null;
  publisherOrDistributorNumber = null;
  abbreviatedNameOfPublisher = null;
  numberOfPart = null;
  nameOfPart = null;
  extent = null;
  musicalPresentationStatement = null;
  volumeDesignation = null;
  relatedParts = null;
  systemControlNumbers = null;
  oclcMap = null;

  recordId = ((List<XmlFieldInstance>) cache.get(getIdPath())).get(0).getValue();
  cache.setRecordId(recordId);
  resultMap.put(FIELD_NAME, Arrays.asList(recordId));
  if (schema != null) {
    String path;
    for (String fieldName : schema.getExtractableFields().keySet()) {
      if (!fieldName.equals(FIELD_NAME)) {
        path = schema.getExtractableFields().get(fieldName);
        List<XmlFieldInstance> instances = (List<XmlFieldInstance>) cache.get(path);
        List<String> values = null;
        if (!isNull(instances)) {
          values = new ArrayList<>();
          for (XmlFieldInstance instance : instances) {
            values.add(instance.getValue());
          }
          if (fieldName.equals("leader")) {
            leader = new Leader(values.get(0));
          }
        }
        resultMap.put(fieldName, values);
      }
    }
  }
  processLeader();
  process007();
  process008();
  processType();
  processTitleWords();
  processAuthorWords();
  processDateOfPublication();
  processIsbn();
  processPublisherOrDistributorNumber();
  processAbbreviatedNameOfPublisher();
  processNumberOfPart();
  processNameOfPart();
  processExtent();
  processMusicalPresentationStatement();
  processVolumeDesignation();
  processRelatedParts();
  processSystemControlNumbers();
  processOclcFields();
  createDuplumKeyMap();
}
 

@Override
public String measure(String jsonRecord) throws InvalidJsonException {
  return this.<EdmFieldInstance>measureWithGenerics(jsonRecord);
}