Java Code Examples for com.jayway.jsonpath.JsonPath#compile()

@Override
public ValidationResult validate(final String subject, final String input, final ValidationContext context) {
    try {
        JsonPath.compile(input);
    } catch (final Exception e) {
        return new ValidationResult.Builder()
            .subject(subject)
            .input(input)
            .valid(false)
            .explanation("Invalid JSON Path Expression: " + e.getMessage())
            .build();
    }

    return new ValidationResult.Builder()
        .subject(subject)
        .input(input)
        .valid(true)
        .build();
}
 

@OnEnabled
public void compileJsonPaths(final ConfigurationContext context) {
    this.dateFormat = context.getProperty(DateTimeUtils.DATE_FORMAT).getValue();
    this.timeFormat = context.getProperty(DateTimeUtils.TIME_FORMAT).getValue();
    this.timestampFormat = context.getProperty(DateTimeUtils.TIMESTAMP_FORMAT).getValue();

    final LinkedHashMap<String, JsonPath> compiled = new LinkedHashMap<>();
    for (final PropertyDescriptor descriptor : context.getProperties().keySet()) {
        if (!descriptor.isDynamic()) {
            continue;
        }

        final String fieldName = descriptor.getName();
        final String expression = context.getProperty(descriptor).getValue();
        final JsonPath jsonPath = JsonPath.compile(expression);
        compiled.put(fieldName, jsonPath);
    }

    jsonPaths = compiled;
}
 

/**
 * Get JSON path to the parent of the object at the given JSON path.
 */
public static String getParentJsonPath(String jsonPathString) {
    JsonPath jsonPath = JsonPath.compile(jsonPathString);
    String compiledPath = jsonPath.getPath();
    Matcher matcher = LAST_ELEMENT_IN_PATH_PATTERN.matcher(compiledPath);
    if (matcher.find()) {
        return compiledPath.replace(matcher.group(1), "");
    }
    throw new IllegalStateException(String.format("Unable to find parent for '%s'", jsonPathString));
}
 

@Override
public void prepare(Object configurationObject) {
  if ( configurationObject instanceof Map) {
    Map<String,String> params = ( Map<String,String>) configurationObject;
    pathExpression = params.get("pathExpression");
    jsonPath = JsonPath.compile(pathExpression);
    destNodeName = pathExpression.substring(pathExpression.lastIndexOf(".") + 1);
  }
}
 

private static JsonPath getPath(String pathStr) {
  JsonPath path;

  if ((path = CACHE.get(pathStr)) == null) {
    path = JsonPath.compile(pathStr);
    CACHE.put(pathStr, path);
  }

  return path;
}
 

static JsonPath compileJsonPathExpression(String exp) {
    try {
        return JsonPath.compile(exp);
    } catch (Exception e) {
        throw new AttributeExpressionLanguageException("Invalid JSON Path expression: " + exp, e);
    }
}
 

public SpinJsonPathQuery jsonPath(String expression) {
  ensureNotNull("expression", expression);
  try {
    JsonPath query = JsonPath.compile(expression);
    return new JacksonJsonPathQuery(this, query, dataFormat);
  } catch(InvalidPathException pex) {
    throw LOG.unableToCompileJsonPathExpression(expression, pex);
  } catch(IllegalArgumentException aex) {
    throw LOG.unableToCompileJsonPathExpression(expression, aex);
  }
}
 

@Override
public ValidationResult validate(final String subject, final String input, final ValidationContext context) {
    String error = null;
    if (isStale(subject, input)) {
        if (JsonPathExpressionValidator.isValidExpression(input)) {
            JsonPath compiledJsonPath = JsonPath.compile(input);
            cacheComputedValue(subject, input, compiledJsonPath);
        } else {
            error = "specified expression was not valid: " + input;
        }
    }
    return new ValidationResult.Builder().subject(subject).valid(error == null).explanation(error).build();
}
 

static JsonPath compileJsonPathExpression(String exp) {
    try {
        return JsonPath.compile(exp);
    } catch (Exception e) {
        throw new AttributeExpressionLanguageException("Invalid JSON Path expression: " + exp, e);
    }
}
 

private static JsonPath[] compilePaths( JsonInputField[] fields ) {
  JsonPath[] paths = new JsonPath[ fields.length ];
  int i = 0;
  for ( JsonInputField field : fields ) {
    paths[ i++ ] = JsonPath.compile( field.getPath() );
  }
  return paths;
}
 

public static JsonPath getValidJsonPath(final String jsonPath) {
    try {
        return JsonPath.compile(jsonPath);
    } catch (IllegalArgumentException iae) {
        throw hammerIllegalArgumentExceptionWithMessage(INVALID_JSONPATH, iae);
    }
}
 

private static JsonPath[] compilePaths( JsonInputField[] fields ) {
  JsonPath[] paths = new JsonPath[ fields.length ];
  int i = 0;
  for ( JsonInputField field : fields ) {
    paths[ i++ ] = JsonPath.compile( field.getPath() );
  }
  return paths;
}
 

/**
 * Get object key at the given JSON path.
 */
public static String getJsonElementKey(String jsonPathString) {
    JsonPath jsonPath = JsonPath.compile(jsonPathString);
    String compiledPath = jsonPath.getPath();
    Matcher matcher = LAST_ELEMENT_IN_PATH_PATTERN.matcher(compiledPath);
    if (matcher.find()) {
        return matcher.group(1).replace("['", "").replace("']", "");
    }
    throw new IllegalStateException(String.format("Unable to find object key for '%s'", jsonPathString));
}
 

public Builder withKeyPath(final String keyPath) {
  this.keyPath = JsonPath.compile(keyPath);
  return this;
}
 

@SuppressWarnings({"rawtypes", "unchecked"})
private void testModifyFeatures(boolean includeOldStates) throws Exception {
  // =========== INSERT ==========
  String insertJsonFile = "/events/InsertFeaturesEvent.json";
  String insertResponse = invokeLambdaFromFile(insertJsonFile);
  logger.info("RAW RESPONSE: " + insertResponse);
  String insertRequest = IOUtils.toString(GSContext.class.getResourceAsStream(insertJsonFile));
  assertRead(insertRequest, insertResponse, false);
  final JsonPath jsonPathFeatures = JsonPath.compile("$.features");
  List<Map> originalFeatures = jsonPathFeatures.read(insertResponse, jsonPathConf);

  final JsonPath jsonPathFeatureIds = JsonPath.compile("$.features..id");
  List<String> ids = jsonPathFeatureIds.read(insertResponse, jsonPathConf);
  logger.info("Preparation: Inserted features {}", ids);

  // =========== UPDATE ==========
  logger.info("Modify features");
  final DocumentContext updateFeaturesEventDoc = getEventFromResource("/events/InsertFeaturesEvent.json");
  updateFeaturesEventDoc.put("$", "params", Collections.singletonMap("includeOldStates", includeOldStates));

  List<Map> updateFeatures = jsonPathFeatures.read(insertResponse, jsonPathConf);
  updateFeaturesEventDoc.delete("$.insertFeatures");
  updateFeatures.forEach((Map feature) -> {
    final Map<String, Object> properties = (Map<String, Object>) feature.get("properties");
    properties.put("test", "updated");
  });
  updateFeaturesEventDoc.put("$", "updateFeatures", updateFeatures);

  String updateFeaturesEvent = updateFeaturesEventDoc.jsonString();
  String updateFeaturesResponse = invokeLambda(updateFeaturesEvent);
  assertNoErrorInResponse(updateFeaturesResponse);

  List features = jsonPathFeatures.read(updateFeaturesResponse, jsonPathConf);
  assertNotNull("'features' element in ModifyFeaturesResponse is missing", features);
  assertTrue("'features' element in ModifyFeaturesResponse is empty", features.size() > 0);

  final JsonPath jsonPathOldFeatures = JsonPath.compile("$.oldFeatures");
  List oldFeatures = jsonPathOldFeatures.read(updateFeaturesResponse, jsonPathConf);
  if (includeOldStates) {
    assertNotNull("'oldFeatures' element in ModifyFeaturesResponse is missing", oldFeatures);
    assertTrue("'oldFeatures' element in ModifyFeaturesResponse is empty", oldFeatures.size() > 0);
    assertEquals(oldFeatures, originalFeatures);
  } else if (oldFeatures != null) {
    assertEquals("unexpected oldFeatures in ModifyFeaturesResponse", 0, oldFeatures.size());
  }

  // =========== DELETE ==========
  final DocumentContext modifyFeaturesEventDoc = getEventFromResource("/events/InsertFeaturesEvent.json");
  modifyFeaturesEventDoc.put("$", "params", Collections.singletonMap("includeOldStates", includeOldStates));
  modifyFeaturesEventDoc.delete("$.insertFeatures");

  Map<String, String> idsMap = new HashMap<>();
  ids.forEach(id -> idsMap.put(id, null));
  modifyFeaturesEventDoc.put("$", "deleteFeatures", idsMap);

  String deleteEvent = modifyFeaturesEventDoc.jsonString();
  String deleteResponse = invokeLambda(deleteEvent);
  assertNoErrorInResponse(deleteResponse);
  oldFeatures = jsonPathOldFeatures.read(deleteResponse, jsonPathConf);
  if (includeOldStates) {
    assertNotNull("'oldFeatures' element in ModifyFeaturesResponse is missing", oldFeatures);
    assertTrue("'oldFeatures' element in ModifyFeaturesResponse is empty", oldFeatures.size() > 0);
    assertEquals(oldFeatures, features);
  } else if (oldFeatures != null) {
    assertEquals("unexpected oldFeatures in ModifyFeaturesResponse", 0, oldFeatures.size());
  }

  logger.info("Modify features tested successfully");
}
 

public Builder withVariablesPath(final String variablesPath) {
  this.variablesPath = JsonPath.compile(variablesPath);
  return this;
}
 

private static Object readJsonElement(DocumentContext context, String jsonPathString) {
    Object payloadJsonObject = context.json();
    JsonPath jsonPath = JsonPath.compile(jsonPathString);
    return jsonPath.read(payloadJsonObject, jsonPathConfig);
}
 

public JsonPathSelector(String jsonPathStr) {
    this.jsonPathStr = jsonPathStr;
    this.jsonPath = JsonPath.compile(this.jsonPathStr);
}
 

/**
 * Construct a new {@code JsonPathExpectationsHelper}.
 * @param expression the {@link JsonPath} expression; never {@code null} or empty
 * @param args arguments to parameterize the {@code JsonPath} expression with,
 * using formatting specifiers defined in {@link String#format(String, Object...)}
 */
public JsonPathExpectationsHelper(String expression, Object... args) {
	Assert.hasText(expression, "expression must not be null or empty");
	this.expression = String.format(expression, args);
	this.jsonPath = JsonPath.compile(this.expression);
}
 

/**
 * Construct a new {@code JsonPathExpectationsHelper}.
 * @param expression the {@link JsonPath} expression; never {@code null} or empty
 * @param args arguments to parameterize the {@code JsonPath} expression with,
 * using formatting specifiers defined in {@link String#format(String, Object...)}
 */
public JsonPathExpectationsHelper(String expression, Object... args) {
	Assert.hasText(expression, "expression must not be null or empty");
	this.expression = String.format(expression, args);
	this.jsonPath = JsonPath.compile(this.expression);
}