How to use

SingleSelectCapability

in

io.spring.initializr.metadata

protected void singleSelect(ObjectNode parent, SingleSelectCapability capability) {
  ObjectNode single = nodeFactory.objectNode();
  single.put("type", capability.getType().getName());
  DefaultMetadataElement defaultType = capability.getDefault();
  if (defaultType != null) {
    single.put("default", defaultType.getId());
  }
  ArrayNode values = nodeFactory.arrayNode();
  values.addAll(capability.getContent().stream().map(this::mapValue)
      .collect(Collectors.toList()));
  single.set("values", values);
  parent.set(capability.getId(), single);
}

@Test
void mergeAddEntry() {
  SingleSelectCapability capability = new SingleSelectCapability("test");
  DefaultMetadataElement foo = DefaultMetadataElement.create("foo", false);
  capability.getContent().add(foo);
  SingleSelectCapability anotherCapability = new SingleSelectCapability("test");
  DefaultMetadataElement bar = DefaultMetadataElement.create("bar", false);
  anotherCapability.getContent().add(bar);
  capability.merge(anotherCapability);
  assertThat(capability.getContent()).hasSize(2);
  assertThat(capability.get("foo")).isEqualTo(foo);
  assertThat(capability.get("bar")).isEqualTo(bar);
}

@Test
void defaultType() {
  SingleSelectCapability capability = new SingleSelectCapability("test");
  capability.getContent().add(DefaultMetadataElement.create("foo", false));
  DefaultMetadataElement second = DefaultMetadataElement.create("bar", true);
  capability.getContent().add(second);
  assertThat(capability.getDefault()).isEqualTo(second);
}

@Test
void bootVersionsAreReplaced() {
  InitializrMetadata metadata = new InitializrMetadataTestBuilder()
      .addBootVersion("0.0.9.RELEASE", true)
      .addBootVersion("0.0.8.RELEASE", false).build();
  assertThat(metadata.getBootVersions().getDefault().getId())
      .isEqualTo("0.0.9.RELEASE");
  DefaultInitializrMetadataProvider provider = new DefaultInitializrMetadataProvider(
      metadata, objectMapper, this.restTemplate);
  expectJson(metadata.getConfiguration().getEnv().getSpringBootMetadataUrl(),
      "metadata/sagan/spring-boot.json");
  InitializrMetadata updatedMetadata = provider.get();
  assertThat(updatedMetadata.getBootVersions()).isNotNull();
  List<DefaultMetadataElement> updatedBootVersions = updatedMetadata
      .getBootVersions().getContent();
  assertThat(updatedBootVersions).hasSize(4);
  assertBootVersion(updatedBootVersions.get(0), "1.4.1 (SNAPSHOT)", false);
  assertBootVersion(updatedBootVersions.get(1), "1.4.0", true);
  assertBootVersion(updatedBootVersions.get(2), "1.3.8 (SNAPSHOT)", false);
  assertBootVersion(updatedBootVersions.get(3), "1.3.7", false);
}

/**
 * Update the available Spring Boot versions with the specified capabilities.
 * @param versionsMetadata the Spring Boot boot versions metadata to use
 */
public void updateSpringBootVersions(List<DefaultMetadataElement> versionsMetadata) {
  this.bootVersions.getContent().clear();
  this.bootVersions.getContent().addAll(versionsMetadata);
  List<Version> bootVersions = this.bootVersions.getContent().stream()
      .map((it) -> Version.parse(it.getId())).collect(Collectors.toList());
  VersionParser parser = new VersionParser(bootVersions);
  this.dependencies.updateVersionRange(parser);
  this.configuration.getEnv().getBoms().values()
      .forEach((it) -> it.updateVersionRange(parser));
  this.configuration.getEnv().getKotlin().updateVersionRange(parser);
}

List<String> depIds = (!getStyle().isEmpty() ? getStyle() : getDependencies());
String actualBootVersion = (getBootVersion() != null) ? getBootVersion()
    : metadata.getBootVersions().getDefault().getId();
Version requestedVersion = Version.parse(actualBootVersion);
this.resolvedDependencies = depIds.stream().map((it) -> {
      .get(getPackaging());
  if (packaging == null) {
    throw new InvalidProjectRequestException("Unknown packaging '"
  DefaultMetadataElement language = metadata.getLanguages().get(getLanguage());
  if (language == null) {
    throw new InvalidProjectRequestException("Unknown language '"

@Test
void defaultEmpty() {
  SingleSelectCapability capability = new SingleSelectCapability("test");
  assertThat(capability.getDefault()).isNull();
}

private ResponseEntity<String> dependenciesFor(InitializrMetadataVersion version,
    String bootVersion) {
  InitializrMetadata metadata = this.metadataProvider.get();
  Version v = (bootVersion != null) ? Version.parse(bootVersion)
      : Version.parse(metadata.getBootVersions().getDefault().getId());
  DependencyMetadata dependencyMetadata = this.dependencyMetadataProvider
      .get(metadata, v);
  String content = new DependencyMetadataV21JsonMapper().write(dependencyMetadata);
  return ResponseEntity.ok().contentType(version.getMediaType())
      .eTag(createUniqueId(content))
      .cacheControl(CacheControl.maxAge(7, TimeUnit.DAYS)).body(content);
}

@Override
public void merge(List<DefaultMetadataElement> otherContent) {
  otherContent.forEach((it) -> {
    if (get(it.getId()) == null) {
      this.content.add(it);
    }
  });
}

/**
 * Merge this instance with the specified argument.
 * @param other the other instance
 */
public void merge(InitializrMetadata other) {
  this.configuration.merge(other.configuration);
  this.dependencies.merge(other.dependencies);
  this.types.merge(other.types);
  this.bootVersions.merge(other.bootVersions);
  this.packagings.merge(other.packagings);
  this.javaVersions.merge(other.javaVersions);
  this.languages.merge(other.languages);
  this.name.merge(other.name);
  this.description.merge(other.description);
  this.groupId.merge(other.groupId);
  this.artifactId.merge(other.artifactId);
  this.version.merge(other.version);
  this.packageName.merge(other.packageName);
}

@Test
void defaultNoDefault() {
  SingleSelectCapability capability = new SingleSelectCapability("test");
  capability.getContent().add(DefaultMetadataElement.create("foo", false));
  capability.getContent().add(DefaultMetadataElement.create("bar", false));
  assertThat(capability.getDefault()).isNull();
}

@Test
void defaultBootVersionIsAlwaysSet() {
  InitializrMetadata metadata = new InitializrMetadataTestBuilder()
      .addBootVersion("0.0.9.RELEASE", true)
      .addBootVersion("0.0.8.RELEASE", false).build();
  assertThat(metadata.getBootVersions().getDefault().getId())
      .isEqualTo("0.0.9.RELEASE");
  DefaultInitializrMetadataProvider provider = new DefaultInitializrMetadataProvider(
      metadata, objectMapper, this.restTemplate);
  expectJson(metadata.getConfiguration().getEnv().getSpringBootMetadataUrl(),
      "metadata/sagan/spring-boot-no-default.json");
  InitializrMetadata updatedMetadata = provider.get();
  assertThat(updatedMetadata.getBootVersions()).isNotNull();
  List<DefaultMetadataElement> updatedBootVersions = updatedMetadata
      .getBootVersions().getContent();
  assertThat(updatedBootVersions).hasSize(4);
  assertBootVersion(updatedBootVersions.get(0), "1.3.1 (SNAPSHOT)", true);
  assertBootVersion(updatedBootVersions.get(1), "1.3.0", false);
  assertBootVersion(updatedBootVersions.get(2), "1.2.6 (SNAPSHOT)", false);
  assertBootVersion(updatedBootVersions.get(3), "1.2.5", false);
}

@Test
void mergeMetadata() {
  InitializrMetadata metadata = InitializrMetadataBuilder.create()
      .withInitializrMetadata(
          new ClassPathResource("metadata/config/test-min.json"))
      .build();
  assertThat(metadata.getConfiguration().getEnv().isForceSsl()).isEqualTo(true);
  assertThat(metadata.getDependencies().getContent()).hasSize(1);
  Dependency dependency = metadata.getDependencies().get("test");
  assertThat(dependency).isNotNull();
  assertThat(dependency.getGroupId()).isEqualTo("org.springframework.boot");
  assertThat(metadata.getTypes().getContent()).hasSize(1);
  assertThat(metadata.getBootVersions().getContent()).hasSize(2);
  assertThat(metadata.getPackagings().getContent()).hasSize(2);
  assertThat(metadata.getJavaVersions().getContent()).hasSize(1);
  assertThat(metadata.getLanguages().getContent()).hasSize(3);
  assertThat(metadata.getName().getContent()).isEqualTo("metadata-merge");
  assertThat(metadata.getDescription().getContent())
      .isEqualTo("Demo project for metadata merge");
  assertThat(metadata.getGroupId().getContent()).isEqualTo("org.acme");
  assertThat(metadata.getArtifactId().getContent()).isEqualTo("metadata");
  assertThat(metadata.getVersion().getContent()).isEqualTo("1.0.0-SNAPSHOT");
  assertThat(metadata.getPackageName().getContent()).isEqualTo("org.acme.demo");
}

@Test
void initializeSetsMetadataDefaults() {
  ProjectRequest request = initProjectRequest();
  assertThat(request.getName()).isEqualTo(this.metadata.getName().getContent());
  assertThat(request.getType())
      .isEqualTo(this.metadata.getTypes().getDefault().getId());
  assertThat(request.getDescription())
      .isEqualTo(this.metadata.getDescription().getContent());
  assertThat(request.getGroupId())
      .isEqualTo(this.metadata.getGroupId().getContent());
  assertThat(request.getArtifactId())
      .isEqualTo(this.metadata.getArtifactId().getContent());
  assertThat(request.getVersion())
      .isEqualTo(this.metadata.getVersion().getContent());
  assertThat(request.getBootVersion())
      .isEqualTo(this.metadata.getBootVersions().getDefault().getId());
  assertThat(request.getPackaging())
      .isEqualTo(this.metadata.getPackagings().getDefault().getId());
}

  && metadata.getJavaVersions().get(request.getJavaVersion()) == null) {
document.triggerError().setJavaVersion(true);
  && metadata.getLanguages().get(request.getLanguage()) == null) {
document.triggerError().setLanguage(true);
  && metadata.getPackagings().get(request.getPackaging()) == null) {
document.triggerError().setPackaging(true);

@Override
public void customize(InitializrMetadata metadata) {
  metadata.getDependencies().merge(this.properties.getDependencies());
  metadata.getTypes().merge(this.properties.getTypes());
  metadata.getBootVersions().merge(this.properties.getBootVersions());
  metadata.getPackagings().merge(this.properties.getPackagings());
  metadata.getJavaVersions().merge(this.properties.getJavaVersions());
  metadata.getLanguages().merge(this.properties.getLanguages());
  this.properties.getGroupId().apply(metadata.getGroupId());
  this.properties.getArtifactId().apply(metadata.getArtifactId());
  this.properties.getVersion().apply(metadata.getVersion());
  this.properties.getName().apply(metadata.getName());
  this.properties.getDescription().apply(metadata.getDescription());
  this.properties.getPackageName().apply(metadata.getPackageName());
}

@Test
void initializeRemoteConfig() throws Exception {
  InitializrMetadata localMetadata = this.metadataProvider.get();
  InitializrMetadata metadata = InitializrMetadataBuilder.create()
      .withInitializrMetadata(new UrlResource(createUrl("/metadata/config")))
      .build();
  // Basic assertions
  assertThat(metadata.getDependencies().getContent())
      .hasSameSizeAs(localMetadata.getDependencies().getContent());
  assertThat(metadata.getTypes().getContent())
      .hasSameSizeAs(localMetadata.getTypes().getContent());
  assertThat(metadata.getBootVersions().getContent())
      .hasSameSizeAs(localMetadata.getBootVersions().getContent());
  assertThat(metadata.getPackagings().getContent())
      .hasSameSizeAs(localMetadata.getPackagings().getContent());
  assertThat(metadata.getJavaVersions().getContent())
      .hasSameSizeAs(localMetadata.getJavaVersions().getContent());
  assertThat(metadata.getLanguages().getContent())
      .hasSameSizeAs(localMetadata.getLanguages().getContent());
}

  && metadata.getJavaVersions().get(request.getJavaVersion()) == null) {
document.setInvalid(true);
document.setInvalidJavaVersion(true);
  && metadata.getLanguages().get(request.getLanguage()) == null) {
document.setInvalid(true);
document.setInvalidLanguage(true);
  && metadata.getPackagings().get(request.getPackaging()) == null) {
document.setInvalid(true);
document.setInvalidPackaging(true);

public InitializrMetadataTestBuilder addPackaging(String id, boolean defaultValue) {
  this.builder.withCustomizer((it) -> {
    DefaultMetadataElement packaging = new DefaultMetadataElement();
    packaging.setId(id);
    packaging.setName(id);
    packaging.setDefault(defaultValue);
    it.getPackagings().getContent().add(packaging);
  });
  return this;
}

public InitializrMetadataTestBuilder addJavaVersion(String version,
    boolean defaultValue) {
  this.builder.withCustomizer((it) -> {
    DefaultMetadataElement element = new DefaultMetadataElement();
    element.setId(version);
    element.setName(version);
    element.setDefault(defaultValue);
    it.getJavaVersions().getContent().add(element);
  });
  return this;
}