org.apache.solr.client.solrj.response.schema.SchemaResponse Java Examples

@Test
public void testDeleteFieldAccuracy() throws Exception {
  String fieldName = "fieldToBeDeleted";
  Map<String, Object> fieldAttributesRequest = new LinkedHashMap<>();
  fieldAttributesRequest.put("name", fieldName);
  fieldAttributesRequest.put("type", "string");
  SchemaRequest.AddField addFieldUpdateSchemaRequest =
      new SchemaRequest.AddField(fieldAttributesRequest);
  SchemaResponse.UpdateResponse addFieldResponse = addFieldUpdateSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(addFieldResponse);

  SchemaRequest.Field fieldSchemaRequest = new SchemaRequest.Field(fieldName);
  SchemaResponse.FieldResponse initialFieldResponse = fieldSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(initialFieldResponse);
  Map<String, Object> fieldAttributesResponse = initialFieldResponse.getField();
  assertThat(fieldName, is(equalTo(fieldAttributesResponse.get("name"))));

  SchemaRequest.DeleteField deleteFieldRequest =
      new SchemaRequest.DeleteField(fieldName);
  SchemaResponse.UpdateResponse deleteFieldResponse = deleteFieldRequest.process(getSolrClient());
  assertValidSchemaResponse(deleteFieldResponse);

  expectThrows(SolrException.class, () -> fieldSchemaRequest.process(getSolrClient()));
}
 

private void testModifyField(String collection) throws IOException, SolrServerException {
  CloudSolrClient cloudClient = cluster.getSolrClient();

  SolrInputDocument doc = new SolrInputDocument("id", "3");
  cloudClient.add(collection, doc);
  cloudClient.commit(collection);

  String fieldName = "id";
  SchemaRequest.Field getFieldRequest = new SchemaRequest.Field(fieldName);
  SchemaResponse.FieldResponse getFieldResponse = getFieldRequest.process(cloudClient, collection);
  Map<String, Object> field = getFieldResponse.getField();
  field.put("docValues", true);
  SchemaRequest.ReplaceField replaceRequest = new SchemaRequest.ReplaceField(field);
  SchemaResponse.UpdateResponse replaceResponse = replaceRequest.process(cloudClient, collection);
  assertNull(replaceResponse.getResponse().get("errors"));
  CollectionAdminRequest.Reload reloadRequest = CollectionAdminRequest.reloadCollection(collection);
  CollectionAdminResponse response = reloadRequest.process(cloudClient);
  assertEquals(0, response.getStatus());
  assertTrue(response.isSuccess());

}
 

@Test
public void testDeleteDynamicFieldAccuracy() throws Exception {
  String dynamicFieldName = "*_del";
  Map<String, Object> fieldAttributes = new LinkedHashMap<>();
  fieldAttributes.put("name", dynamicFieldName);
  fieldAttributes.put("type", "string");
  SchemaRequest.AddDynamicField addFieldUpdateSchemaRequest =
      new SchemaRequest.AddDynamicField(fieldAttributes);
  SchemaResponse.UpdateResponse addDynamicFieldResponse = addFieldUpdateSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(addDynamicFieldResponse);

  SchemaRequest.DynamicField dynamicFieldSchemaRequest =
      new SchemaRequest.DynamicField(dynamicFieldName);
  SchemaResponse.DynamicFieldResponse initialDFieldResponse = dynamicFieldSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(initialDFieldResponse);
  Map<String, Object> fieldAttributesResponse = initialDFieldResponse.getDynamicField();
  assertThat(dynamicFieldName, is(equalTo(fieldAttributesResponse.get("name"))));

  SchemaRequest.DeleteDynamicField deleteFieldRequest =
      new SchemaRequest.DeleteDynamicField(dynamicFieldName);
  SchemaResponse.UpdateResponse deleteDynamicFieldResponse = deleteFieldRequest.process(getSolrClient());
  assertValidSchemaResponse(deleteDynamicFieldResponse);

  expectThrows(SolrException.class, () -> dynamicFieldSchemaRequest.process(getSolrClient()));
}
 

@Test
public void testDeleteCopyFieldAccuracy() throws Exception {
  String srcFieldName = "copyfield";
  String destFieldName1 = "destField1", destFieldName2 = "destField2";
  createStoredStringField(srcFieldName, getSolrClient());
  createStoredStringField(destFieldName1, getSolrClient());
  createStoredStringField(destFieldName2, getSolrClient());

  SchemaRequest.AddCopyField addCopyFieldRequest =
      new SchemaRequest.AddCopyField(srcFieldName,
          Arrays.asList(destFieldName1, destFieldName2));
  SchemaResponse.UpdateResponse addCopyFieldResponse = addCopyFieldRequest.process(getSolrClient());
  System.out.println(addCopyFieldResponse);
  assertValidSchemaResponse(addCopyFieldResponse);

  SchemaRequest.DeleteCopyField deleteCopyFieldRequest1 =
      new SchemaRequest.DeleteCopyField(srcFieldName, Arrays.asList(destFieldName1));
  assertValidSchemaResponse(deleteCopyFieldRequest1.process(getSolrClient()));

  SchemaRequest.DeleteCopyField deleteCopyFieldRequest2 =
      new SchemaRequest.DeleteCopyField(srcFieldName, Arrays.asList(destFieldName2));
  assertValidSchemaResponse(deleteCopyFieldRequest2.process(getSolrClient()));
}
 

@Test
public void testCopyFieldAccuracy() throws Exception {
  SchemaRequest.CopyFields copyFieldsSchemaRequest = new SchemaRequest.CopyFields();
  SchemaResponse.CopyFieldsResponse initialCopyFieldsResponse = copyFieldsSchemaRequest.process(getSolrClient());
  List<Map<String, Object>> initialCopyFieldsAttributes = initialCopyFieldsResponse.getCopyFields();

  String srcFieldName = "copyfield";
  String destFieldName1 = "destField1", destFieldName2 = "destField2";
  createStoredStringField(srcFieldName, getSolrClient());
  createStoredStringField(destFieldName1, getSolrClient());
  createStoredStringField(destFieldName2, getSolrClient());

  SchemaRequest.AddCopyField addCopyFieldRequest =
      new SchemaRequest.AddCopyField(srcFieldName,
          Arrays.asList(destFieldName1, destFieldName2));
  SchemaResponse.UpdateResponse addCopyFieldResponse = addCopyFieldRequest.process(getSolrClient());
  assertValidSchemaResponse(addCopyFieldResponse);

  SchemaResponse.CopyFieldsResponse currentCopyFieldsResponse = copyFieldsSchemaRequest.process(getSolrClient());
  List<Map<String, Object>> currentCopyFields = currentCopyFieldsResponse.getCopyFields();
  assertEquals(initialCopyFieldsAttributes.size() + 2, currentCopyFields.size());
}
 

@Test
public void addFieldTypeShouldntBeCalledTwiceWithTheSameName() throws Exception {
  Map<String, Object> fieldTypeAttributes = new LinkedHashMap<>();
  String fieldName = "failureInt";
  fieldTypeAttributes.put("name", fieldName);
  fieldTypeAttributes.put("class",  RANDOMIZED_NUMERIC_FIELDTYPES.get(Integer.class));
  fieldTypeAttributes.put("omitNorms", true);
  fieldTypeAttributes.put("positionIncrementGap", 0);
  FieldTypeDefinition fieldTypeDefinition = new FieldTypeDefinition();
  fieldTypeDefinition.setAttributes(fieldTypeAttributes);
  SchemaRequest.AddFieldType addFieldTypeRequest =
      new SchemaRequest.AddFieldType(fieldTypeDefinition);
  SchemaResponse.UpdateResponse addFieldTypeFirstResponse = addFieldTypeRequest.process(getSolrClient());
  assertValidSchemaResponse(addFieldTypeFirstResponse);

  assertFailedSchemaResponse(() -> addFieldTypeRequest.process(getSolrClient()),
      "Field type '" + fieldName + "' already exists.");
}
 

@Test
public void testGetGlobalSimilarityAccuracy() throws Exception {
  SchemaRequest.GlobalSimilarity globalSimilarityRequest =
      new SchemaRequest.GlobalSimilarity();
  SchemaResponse.GlobalSimilarityResponse globalSimilarityResponse = globalSimilarityRequest.process(getSolrClient());
  assertValidSchemaResponse(globalSimilarityResponse);
  assertEquals("org.apache.solr.search.similarities.SchemaSimilarityFactory",
      globalSimilarityResponse.getSimilarity().get("class"));
}
 

@Test
public void testAddFieldAccuracy() throws Exception {
  SchemaRequest.Fields fieldsSchemaRequest = new SchemaRequest.Fields();
  SchemaResponse.FieldsResponse initialFieldsResponse = fieldsSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(initialFieldsResponse);
  List<Map<String, Object>> initialFields = initialFieldsResponse.getFields();

  String fieldName = "accuracyField";
  Map<String, Object> fieldAttributes = new LinkedHashMap<>();
  fieldAttributes.put("name", fieldName);
  fieldAttributes.put("type", "string");
  fieldAttributes.put("stored", false);
  fieldAttributes.put("indexed", true);
  fieldAttributes.put("default", "accuracy");
  fieldAttributes.put("required", true);
  SchemaRequest.AddField addFieldUpdateSchemaRequest =
      new SchemaRequest.AddField(fieldAttributes);
  SchemaResponse.UpdateResponse addFieldResponse = addFieldUpdateSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(addFieldResponse);

  SchemaResponse.FieldsResponse currentFieldsResponse = fieldsSchemaRequest.process(getSolrClient());
  assertEquals(0, currentFieldsResponse.getStatus());
  List<Map<String, Object>> currentFields = currentFieldsResponse.getFields();
  assertEquals(initialFields.size() + 1, currentFields.size());


  SchemaRequest.Field fieldSchemaRequest = new SchemaRequest.Field(fieldName);
  SchemaResponse.FieldResponse newFieldResponse = fieldSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(newFieldResponse);
  Map<String, Object> newFieldAttributes = newFieldResponse.getField();
  assertThat(fieldName, is(equalTo(newFieldAttributes.get("name"))));
  assertThat("string", is(equalTo(newFieldAttributes.get("type"))));
  assertThat(false, is(equalTo(newFieldAttributes.get("stored"))));
  assertThat(true, is(equalTo(newFieldAttributes.get("indexed"))));
  assertThat("accuracy", is(equalTo(newFieldAttributes.get("default"))));
  assertThat(true, is(equalTo(newFieldAttributes.get("required"))));
}
 

private void populateSchemaFields(CloudSolrClient solrClient, Map<String, String> schemaFieldNameMap,
    Map<String, String> schemaFieldTypeMap) {
  if (solrClient != null) {
    logger.debug("Started thread to get fields for collection=" + solrClient.getDefaultCollection());
    List<LukeResponse> lukeResponses = null;
    SchemaResponse schemaResponse = null;
    try {
      lukeResponses = getLukeResponsesForCores(solrClient);

      SolrRequest<SchemaResponse> schemaRequest = new SchemaRequest();
      schemaRequest.setMethod(SolrRequest.METHOD.GET);
      schemaRequest.setPath("/schema");
      schemaResponse = schemaRequest.process(solrClient);
      
      logger.debug("populateSchemaFields() collection=" + solrClient.getDefaultCollection() + ", luke=" + lukeResponses +
          ", schema= " + schemaResponse);
    } catch (SolrException | SolrServerException | IOException e) {
      logger.error("Error occured while popuplating field. collection=" + solrClient.getDefaultCollection(), e);
    }

    if (schemaResponse != null) {
      extractSchemaFieldsName(lukeResponses, schemaResponse, schemaFieldNameMap, schemaFieldTypeMap);
      logger.debug("Populate fields for collection " + solrClient.getDefaultCollection()+ " was successful, next update it after " +
          solrMetadataPropsConfig.getPopulateIntervalMins() + " minutes");
      retryCount = 0;
      skipCount = (solrMetadataPropsConfig.getPopulateIntervalMins() * 60) / RETRY_SECOND - 1;
    }
    else {
      retryCount++;
      logger.error("Error while populating fields for collection " + solrClient.getDefaultCollection() + ", retryCount=" + retryCount);
    }
  }
}
 

@Test
public void addFieldShouldntBeCalledTwiceWithTheSameName() throws Exception {
  Map<String, Object> fieldAttributes = new LinkedHashMap<>();
  String fieldName = "failureField"; 
  fieldAttributes.put("name", fieldName);
  fieldAttributes.put("type", "string");
  SchemaRequest.AddField addFieldUpdateSchemaRequest =
      new SchemaRequest.AddField(fieldAttributes);
  SchemaResponse.UpdateResponse addFieldFirstResponse = addFieldUpdateSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(addFieldFirstResponse);

  assertFailedSchemaResponse(() -> addFieldUpdateSchemaRequest.process(getSolrClient()),
      "Field '" + fieldName + "' already exists.");
}
 

@Test
public void testReplaceFieldAccuracy() throws Exception {
  // Given
  Map<String, Object> fieldAttributes = new LinkedHashMap<>();
  String fieldName = "accuracyField";
  fieldAttributes.put("name", fieldName);
  fieldAttributes.put("type", "string");
  fieldAttributes.put("stored", false);
  fieldAttributes.put("indexed", true);
  fieldAttributes.put("required", true);
  SchemaRequest.AddField addFieldUpdateSchemaRequest =
      new SchemaRequest.AddField(fieldAttributes);
  SchemaResponse.UpdateResponse addFieldResponse = addFieldUpdateSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(addFieldResponse);

  // When : update the field definition
  fieldAttributes.put("stored", true);
  fieldAttributes.put("indexed", false);
  SchemaRequest.ReplaceField replaceFieldRequest = new SchemaRequest.ReplaceField(fieldAttributes);
  SchemaResponse.UpdateResponse replaceFieldResponse = replaceFieldRequest.process(getSolrClient());
  assertValidSchemaResponse(replaceFieldResponse);

  // Then
  SchemaRequest.Field fieldSchemaRequest = new SchemaRequest.Field(fieldName);
  SchemaResponse.FieldResponse newFieldResponse = fieldSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(newFieldResponse);
  Map<String, Object> newFieldAttributes = newFieldResponse.getField();
  assertThat(fieldName, is(equalTo(newFieldAttributes.get("name"))));
  assertThat("string", is(equalTo(newFieldAttributes.get("type"))));
  assertThat(true, is(equalTo(newFieldAttributes.get("stored"))));
  assertThat(false, is(equalTo(newFieldAttributes.get("indexed"))));
  assertThat(true, is(equalTo(newFieldAttributes.get("required"))));
}
 

@Test
public void testAddDynamicFieldAccuracy() throws Exception {
  SchemaRequest.DynamicFields dynamicFieldsSchemaRequest =
      new SchemaRequest.DynamicFields();
  SchemaResponse.DynamicFieldsResponse initialDFieldsResponse = dynamicFieldsSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(initialDFieldsResponse);
  List<Map<String, Object>> initialDFields = initialDFieldsResponse.getDynamicFields();

  String dFieldName = "*_acc";
  Map<String, Object> fieldAttributes = new LinkedHashMap<>();
  fieldAttributes.put("name", dFieldName);
  fieldAttributes.put("type", "string");
  fieldAttributes.put("stored", false);
  fieldAttributes.put("indexed", true);
  // Dynamic fields cannot be required or have a default value
  SchemaRequest.AddDynamicField addFieldUpdateSchemaRequest =
      new SchemaRequest.AddDynamicField(fieldAttributes);
  SchemaResponse.UpdateResponse addFieldResponse = addFieldUpdateSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(addFieldResponse);

  SchemaResponse.DynamicFieldsResponse currentDFieldsResponse = dynamicFieldsSchemaRequest.process(getSolrClient());
  assertEquals(0, currentDFieldsResponse.getStatus());
  List<Map<String, Object>> currentFields = currentDFieldsResponse.getDynamicFields();
  assertEquals(initialDFields.size() + 1, currentFields.size());


  SchemaRequest.DynamicField dFieldRequest = new SchemaRequest.DynamicField(dFieldName);
  SchemaResponse.DynamicFieldResponse newFieldResponse = dFieldRequest.process(getSolrClient());
  assertValidSchemaResponse(newFieldResponse);
  Map<String, Object> newFieldAttributes = newFieldResponse.getDynamicField();
  assertThat(dFieldName, is(equalTo(newFieldAttributes.get("name"))));
  assertThat("string", is(equalTo(newFieldAttributes.get("type"))));
  assertThat(false, is(equalTo(newFieldAttributes.get("stored"))));
  assertThat(true, is(equalTo(newFieldAttributes.get("indexed"))));
}
 

@Test
public void addDynamicFieldShouldntBeCalledTwiceWithTheSameName() throws Exception {
  Map<String, Object> fieldAttributes = new LinkedHashMap<>();
  String dynamicFieldName = "*_failure";
  fieldAttributes.put("name", dynamicFieldName);
  fieldAttributes.put("type", "string");
  SchemaRequest.AddDynamicField addDFieldUpdateSchemaRequest =
      new SchemaRequest.AddDynamicField(fieldAttributes);
  SolrClient client = getSolrClient();
  SchemaResponse.UpdateResponse addDFieldFirstResponse = addDFieldUpdateSchemaRequest.process(client);
  assertValidSchemaResponse(addDFieldFirstResponse);

  assertFailedSchemaResponse(() -> addDFieldUpdateSchemaRequest.process(getSolrClient()),
      "[schema.xml] Duplicate DynamicField definition for '" + dynamicFieldName + "'");
}
 

@Test
public void testReplaceDynamicFieldAccuracy() throws Exception {
  // Given
  String fieldName = "*_replace";
  Map<String, Object> fieldAttributes = new LinkedHashMap<>();
  fieldAttributes.put("name", fieldName);
  fieldAttributes.put("type", "string");
  fieldAttributes.put("stored", false);
  fieldAttributes.put("indexed", true);
  SchemaRequest.AddDynamicField addDFieldUpdateSchemaRequest =
      new SchemaRequest.AddDynamicField(fieldAttributes);
  SchemaResponse.UpdateResponse addFieldResponse = addDFieldUpdateSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(addFieldResponse);

  // When : update the field definition
  Map<String, Object> replaceFieldAttributes = new LinkedHashMap<>(fieldAttributes);
  replaceFieldAttributes.put("stored", true);
  replaceFieldAttributes.put("indexed", false);
  SchemaRequest.ReplaceDynamicField replaceFieldRequest =
      new SchemaRequest.ReplaceDynamicField(replaceFieldAttributes);
  SchemaResponse.UpdateResponse replaceFieldResponse = replaceFieldRequest.process(getSolrClient());
  assertValidSchemaResponse(replaceFieldResponse);

  // Then
  SchemaRequest.DynamicField dynamicFieldSchemaRequest =
      new SchemaRequest.DynamicField(fieldName);
  SchemaResponse.DynamicFieldResponse newFieldResponse = dynamicFieldSchemaRequest.process(getSolrClient());
  assertValidSchemaResponse(newFieldResponse);
  Map<String, Object> newFieldAttributes = newFieldResponse.getDynamicField();
  assertThat(fieldName, is(equalTo(newFieldAttributes.get("name"))));
  assertThat("string", is(equalTo(newFieldAttributes.get("type"))));
  assertThat(true, is(equalTo(newFieldAttributes.get("stored"))));
  assertThat(false, is(equalTo(newFieldAttributes.get("indexed"))));
}
 

@Test
public void addFieldTypeWithSimilarityAccuracy() throws Exception {
  FieldTypeDefinition fieldTypeDefinition = new FieldTypeDefinition();
  Map<String, Object> fieldTypeAttributes = new LinkedHashMap<>();
  String fieldTypeName = "fullClassNames";
  fieldTypeAttributes.put("name", fieldTypeName);
  fieldTypeAttributes.put("class", "org.apache.solr.schema.TextField");
  fieldTypeDefinition.setAttributes(fieldTypeAttributes);

  AnalyzerDefinition analyzerDefinition = new AnalyzerDefinition();
  Map<String, Object> charFilterAttributes = new LinkedHashMap<>();
  charFilterAttributes.put("class", "solr.PatternReplaceCharFilterFactory");
  charFilterAttributes.put("replacement", "$1$1");
  charFilterAttributes.put("pattern", "([a-zA-Z])\\\\1+");
  analyzerDefinition.setCharFilters(Collections.singletonList(charFilterAttributes));
  Map<String, Object> tokenizerAttributes = new LinkedHashMap<>();
  tokenizerAttributes.put("class", "solr.WhitespaceTokenizerFactory");
  analyzerDefinition.setTokenizer(tokenizerAttributes);
  fieldTypeDefinition.setAnalyzer(analyzerDefinition);
  Map<String, Object> similarityAttributes = new LinkedHashMap<>();
  similarityAttributes.put("class", "org.apache.lucene.misc.SweetSpotSimilarity");
  fieldTypeDefinition.setSimilarity(similarityAttributes);

  SchemaRequest.AddFieldType addFieldTypeRequest =
      new SchemaRequest.AddFieldType(fieldTypeDefinition);
  SchemaResponse.UpdateResponse addFieldTypeResponse = addFieldTypeRequest.process(getSolrClient());
  assertValidSchemaResponse(addFieldTypeResponse);

  // similarity is not shown by default for the fieldType
  SchemaRequest.FieldType fieldTypeRequest = new SchemaRequest.FieldType(fieldTypeName);
  SchemaResponse.FieldTypeResponse newFieldTypeResponse = fieldTypeRequest.process(getSolrClient());
  assertValidSchemaResponse(newFieldTypeResponse);
  FieldTypeRepresentation newFieldTypeRepresentation = newFieldTypeResponse.getFieldType();
  assertThat(fieldTypeName, is(equalTo(newFieldTypeRepresentation.getAttributes().get("name"))));
  assertThat(similarityAttributes.get("class"), is(equalTo(newFieldTypeRepresentation.getSimilarity().get("class"))));
}
 

@Test
public void addFieldTypeWithAnalyzerClassAccuracy() throws Exception {
  Map<String, Object> fieldTypeAttributes = new LinkedHashMap<>();
  String fieldTypeName = "nameText";
  fieldTypeAttributes.put("name", fieldTypeName);
  fieldTypeAttributes.put("class", "solr.TextField");

  FieldTypeDefinition fieldTypeDefinition = new FieldTypeDefinition();
  fieldTypeDefinition.setAttributes(fieldTypeAttributes);
  Map<String, Object> analyzerAttributes = new LinkedHashMap<>();
  analyzerAttributes.put("class", "org.apache.lucene.analysis.core.WhitespaceAnalyzer");
  analyzerAttributes.put("luceneMatchVersion", "5.0.0");
  AnalyzerDefinition analyzerDefinition = new AnalyzerDefinition();
  analyzerDefinition.setAttributes(analyzerAttributes);
  fieldTypeDefinition.setAnalyzer(analyzerDefinition);


  SchemaRequest.AddFieldType addFieldTypeRequest =
      new SchemaRequest.AddFieldType(fieldTypeDefinition);
  SchemaResponse.UpdateResponse addFieldTypeResponse = addFieldTypeRequest.process(getSolrClient());
  assertValidSchemaResponse(addFieldTypeResponse);

  SchemaRequest.FieldType fieldTypeRequest = new SchemaRequest.FieldType(fieldTypeName);
  SchemaResponse.FieldTypeResponse newFieldTypeResponse = fieldTypeRequest.process(getSolrClient());
  assertValidSchemaResponse(newFieldTypeResponse);
  FieldTypeRepresentation newFieldTypeRepresentation = newFieldTypeResponse.getFieldType();
  assertThat(fieldTypeName, is(equalTo(newFieldTypeRepresentation.getAttributes().get("name"))));
  assertThat(analyzerAttributes.get("class"),
      is(equalTo(newFieldTypeRepresentation.getAnalyzer().getAttributes().get("class"))));
  assertThat(analyzerAttributes.get("luceneMatchVersion"),
      is(equalTo(newFieldTypeRepresentation.getAnalyzer().getAttributes().get("luceneMatchVersion"))));
}
 

@Test
public void testDeleteFieldTypeAccuracy() throws Exception {
  Map<String, Object> fieldTypeAttributes = new LinkedHashMap<>();
  String fieldTypeName = "delInt";
  fieldTypeAttributes.put("name", fieldTypeName);
  fieldTypeAttributes.put("class",  RANDOMIZED_NUMERIC_FIELDTYPES.get(Integer.class));
  fieldTypeAttributes.put("omitNorms", true);
  fieldTypeAttributes.put("positionIncrementGap", 0);
  FieldTypeDefinition fieldTypeDefinition = new FieldTypeDefinition();
  fieldTypeDefinition.setAttributes(fieldTypeAttributes);
  SchemaRequest.AddFieldType addFieldTypeRequest =
      new SchemaRequest.AddFieldType(fieldTypeDefinition);
  SolrClient c = getSolrClient();
  SchemaResponse.UpdateResponse addFieldTypeResponse = addFieldTypeRequest.process(c);
  assertValidSchemaResponse(addFieldTypeResponse);

  SchemaRequest.FieldType fieldTypeRequest = new SchemaRequest.FieldType(fieldTypeName);
  SchemaResponse.FieldTypeResponse initialFieldTypeResponse = fieldTypeRequest.process(getSolrClient());
  assertValidSchemaResponse(initialFieldTypeResponse);
  FieldTypeRepresentation responseFieldTypeRepresentation = initialFieldTypeResponse.getFieldType();
  assertThat(fieldTypeName, is(equalTo(responseFieldTypeRepresentation.getAttributes().get("name"))));

  SchemaRequest.DeleteFieldType deleteFieldTypeRequest =
      new SchemaRequest.DeleteFieldType(fieldTypeName);
  SchemaResponse.UpdateResponse deleteFieldTypeResponse = deleteFieldTypeRequest.process(getSolrClient());
  assertValidSchemaResponse(deleteFieldTypeResponse);

  try {
    fieldTypeRequest.process(getSolrClient());
    fail(String.format(Locale.ROOT, "after removal, the field type %s shouldn't be anymore available over Schema API",
        fieldTypeName));
  } catch (SolrException e) {
    //success
  }
}
 

@Test
public void testCopyFieldWithMaxCharsAccuracy() throws Exception {
  SchemaRequest.CopyFields copyFieldsSchemaRequest = new SchemaRequest.CopyFields();
  SchemaResponse.CopyFieldsResponse initialCopyFieldsResponse = copyFieldsSchemaRequest.process(getSolrClient());
  List<Map<String, Object>> initialCopyFieldsAttributes = initialCopyFieldsResponse.getCopyFields();

  String srcFieldName = "copyfield";
  String destFieldName1 = "destField1", destFieldName2 = "destField2";
  createStoredStringField(srcFieldName, getSolrClient());
  createStoredStringField(destFieldName1, getSolrClient());
  createStoredStringField(destFieldName2, getSolrClient());

  Integer maxChars = 200;
  SchemaRequest.AddCopyField addCopyFieldRequest =
      new SchemaRequest.AddCopyField(srcFieldName,
          Arrays.asList(destFieldName1, destFieldName2), maxChars);
  SchemaResponse.UpdateResponse addCopyFieldResponse = addCopyFieldRequest.process(getSolrClient());
  assertValidSchemaResponse(addCopyFieldResponse);

  SchemaResponse.CopyFieldsResponse currentCopyFieldsResponse = copyFieldsSchemaRequest.process(getSolrClient());
  List<Map<String, Object>> currentCopyFields = currentCopyFieldsResponse.getCopyFields();
  assertEquals(initialCopyFieldsAttributes.size() + 2, currentCopyFields.size());
  for (Map<String, Object> currentCopyField : currentCopyFields) {
    if (srcFieldName.equals(currentCopyField.get("source"))) {
      String currentDestFieldName = (String) currentCopyField.get("dest");
      int currentMaxChars = (Integer) currentCopyField.get("maxChars");
      assertThat(currentDestFieldName, anyOf(is(equalTo(destFieldName1)), is(equalTo(destFieldName2))));
      assertTrue(maxChars == currentMaxChars);
    }
  }
}
 

@Test
public void testSchemaAddFieldAndVerifyExistence() throws Exception {
  assumeTrue("it needs to ammend schema", Boolean.getBoolean("managed.schema.mutable"));
  SchemaResponse.UpdateResponse addFieldResponse = new SchemaRequest.AddField(fieldAttributes).process(server);

  assertEquals(addFieldResponse.toString(), 0, addFieldResponse.getStatus());

  // This asserts that the field was actually created
  // this is due to the fact that the response gave OK but actually never created the field.
  Map<String,Object> foundFieldAttributes = new SchemaRequest.Field(fieldName).process(server).getField();
  assertEquals(fieldAttributes, foundFieldAttributes);

  assertEquals("removing " + fieldName, 0,
      new SchemaRequest.DeleteField(fieldName).process(server).getStatus());
}
 

private Map<String, Object> getSchemaField(String name, SchemaResponse schemaResponse) {
  List<Map<String, Object>> fields = schemaResponse.getSchemaRepresentation().getFields();
  for (Map<String, Object> field : fields) {
    if (name.equals(field.get("name"))) {
      return field;
    }
  }
  return null;
}
 

private void addField(SolrClient client, Map<String,Object> field) throws Exception {
  SchemaResponse.UpdateResponse addFieldResponse = new SchemaRequest.AddField(field).process(client, COLLECTION);
  assertNotNull(addFieldResponse);
  assertEquals(0, addFieldResponse.getStatus());
  assertNull(addFieldResponse.getResponse().get("errors"));
  String fieldName = field.get("name").toString();
  SchemaResponse.FieldResponse fieldResponse = new SchemaRequest.Field(fieldName).process(client, COLLECTION);
  assertNotNull(fieldResponse);
  assertEquals(0, fieldResponse.getStatus());
}
 

@Test
// commented 4-Sep-2018 @BadApple(bugUrl="https://issues.apache.org/jira/browse/SOLR-12028") // added 23-Aug-2018
public void testAddTheSameFieldTwice() throws Exception {
  CloudSolrClient client = cluster.getSolrClient();
  SchemaRequest.Update fieldAddition = new SchemaRequest.AddField
      (Utils.makeMap("name","myfield", "type","string"));
  SchemaResponse.UpdateResponse updateResponse = fieldAddition.process(client, COLLECTION);

  BaseHttpSolrClient.RemoteExecutionException ex = expectThrows(BaseHttpSolrClient.RemoteExecutionException.class,
      () -> fieldAddition.process(client, COLLECTION));

  assertTrue("expected error message 'Field 'myfield' already exists'.",Utils.getObjectByPath(ex.getMetaData(), false, "error/details[0]/errorMessages[0]").toString().contains("Field 'myfield' already exists.") );

}
 

private void addStringField(String fieldName, String collection, CloudSolrClient cloudClient) throws IOException, SolrServerException {
  Map<String, Object> fieldAttributes = new LinkedHashMap<>();
  fieldAttributes.put("name", fieldName);
  fieldAttributes.put("type", "string");
  SchemaRequest.AddField addFieldUpdateSchemaRequest = new SchemaRequest.AddField(fieldAttributes);
  SchemaResponse.UpdateResponse addFieldResponse = addFieldUpdateSchemaRequest.process(cloudClient, collection);
  assertEquals(0, addFieldResponse.getStatus());
  assertNull(addFieldResponse.getResponse().get("errors"));

  log.info("added new field={}", fieldName);
}
 

private void getRequiredFieldNames() throws SolrServerException, IOException {
  SchemaRequest schemaRequest = new SchemaRequest();
  SchemaResponse schemaResponse = schemaRequest.process(solrClient);
  SchemaRepresentation schemaRepresentation = schemaResponse.getSchemaRepresentation();
  List<Map<String, Object>> fields = schemaRepresentation.getFields();
  for (Map<String, Object> field : fields) {
    if (field.containsKey(REQUIRED) && field.get(REQUIRED).equals(true)) {
      requiredFieldNamesMap.add(field.get(NAME).toString());
    }
  }
}
 

private void getOptionalFieldNames() throws SolrServerException, IOException {
  SchemaRequest schemaRequest = new SchemaRequest();
  SchemaResponse schemaResponse = schemaRequest.process(solrClient);
  SchemaRepresentation schemaRepresentation = schemaResponse.getSchemaRepresentation();
  List<Map<String, Object>> fields = schemaRepresentation.getFields();
  for (Map<String, Object> field : fields) {
    if (!field.containsKey(REQUIRED) || field.get(REQUIRED).equals(false)) {
      requiredFieldNamesMap.add(field.get(NAME).toString());
    }
  }
}
 

private void getRequiredFieldNames() throws SolrServerException, IOException {
  SchemaRequest schemaRequest = new SchemaRequest();
  SchemaResponse schemaResponse = schemaRequest.process(solrClient);
  SchemaRepresentation schemaRepresentation = schemaResponse.getSchemaRepresentation();
  List<Map<String, Object>> fields = schemaRepresentation.getFields();
  for (Map<String, Object> field : fields) {
    if (field.containsKey(REQUIRED) && field.get(REQUIRED).equals(true)) {
      requiredFieldNamesMap.add(field.get(NAME).toString());
    }
  }
}
 

private void getOptionalFieldNames() throws SolrServerException, IOException {
  SchemaRequest schemaRequest = new SchemaRequest();
  SchemaResponse schemaResponse = schemaRequest.process(solrClient);
  SchemaRepresentation schemaRepresentation = schemaResponse.getSchemaRepresentation();
  List<Map<String, Object>> fields = schemaRepresentation.getFields();
  for (Map<String, Object> field : fields) {
    if (!field.containsKey(REQUIRED) || field.get(REQUIRED).equals(false)) {
      optionalFieldNamesMap.add(field.get(NAME).toString());
    }
  }
}
 

@Test
public void testGetCopyFieldsAccuracy() throws Exception {
  SchemaRequest.CopyFields copyFieldsRequest =
      new SchemaRequest.CopyFields();
  SchemaResponse.CopyFieldsResponse copyFieldsResponse = copyFieldsRequest.process(getSolrClient());
  assertValidSchemaResponse(copyFieldsResponse);
  List<Map<String, Object>> copyFieldsAttributes = copyFieldsResponse.getCopyFields();
  assertThat(copyFieldsAttributes.isEmpty(), is(false));
}
 

public static void checkSchema(InputStream solrSchemaPath, SchemaResponse response) throws IOException, SchemaValidationException {
    // read the local schema.xml
    final Document local;
    try {
        final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        final DocumentBuilder builder = factory.newDocumentBuilder();

        local = builder.parse(solrSchemaPath);
    } catch (ParserConfigurationException | SAXException e) {
        log.error("Error checking schema.xml: {}", e.getMessage(), e);
        throw new IOException(e);
    }

    final SchemaRepresentation remote = response.getSchemaRepresentation();
    final Element schema = local.getDocumentElement();
    // check the field-types
    final NodeList fieldTypes = schema.getElementsByTagName("fieldType");
    final Set<String> fieldTypeNames = remote.getFieldTypes().stream()
            .map(FieldTypeDefinition::getAttributes)
            .map(m -> m.get("name"))
            .filter(Objects::nonNull)
            .map(String::valueOf)
            .collect(Collectors.toSet());
    for (int i = 0; i < fieldTypes.getLength(); i++) {
        final Node fieldType = fieldTypes.item(i);
        final String fieldTypeName = fieldType.getAttributes().getNamedItem("name").getNodeValue();
        if (! fieldTypeNames.contains(fieldTypeName)) {
            throw new SchemaValidationException(String.format("Missing <fieldType name='%s' />", fieldTypeName));
        }
    }
// TODO: check local -> remote.

}
 

@Test
public void testSchemaRequestAccuracy() throws Exception {
  SchemaRequest schemaRequest = new SchemaRequest();
  SchemaResponse schemaResponse = schemaRequest.process(getSolrClient());
  assertValidSchemaResponse(schemaResponse);
  SchemaRepresentation schemaRepresentation = schemaResponse.getSchemaRepresentation();
  assertNotNull(schemaRepresentation);
  assertEquals("test", schemaRepresentation.getName());
  assertEquals(1.6, schemaRepresentation.getVersion(), 0.001f);
  assertEquals("id", schemaRepresentation.getUniqueKey());
  assertFalse(schemaRepresentation.getFields().isEmpty());
  assertFalse(schemaRepresentation.getDynamicFields().isEmpty());
  assertFalse(schemaRepresentation.getFieldTypes().isEmpty());
  assertFalse(schemaRepresentation.getCopyFields().isEmpty());
}