How to use

PackageConfiguration

in

com.thoughtworks.go.plugin.access.packagematerial

@Test
public void shouldGetOptionValue() {
  PackageConfiguration packageConfiguration = new PackageConfiguration("key");
  packageConfiguration.with(PackageConfiguration.DISPLAY_NAME, "some display name");
  packageConfiguration.with(PackageConfiguration.DISPLAY_ORDER, 3);
  assertThat(packageConfiguration.getOption(PackageConfiguration.DISPLAY_NAME), is("some display name"));
  assertThat(packageConfiguration.getOption(PackageConfiguration.DISPLAY_ORDER), is(3));
}

public PackageConfiguration get(String key) {
  for (PackageConfiguration packageConfiguration : packageConfigurations) {
    if (packageConfiguration.getKey().equals(key)) {
      return packageConfiguration;
    }
  }
  return null;
}

@Test
public void shouldGetOptionIfAvailable() {
  PackageConfiguration packageConfiguration = new PackageConfiguration("key");
  packageConfiguration.with(PackageConfiguration.REQUIRED, true);
  assertThat(packageConfiguration.hasOption(PackageConfiguration.REQUIRED), is(true));
  assertThat(packageConfiguration.hasOption(PackageConfiguration.SECURE), is(false));
}

  @Test
  public void shouldSortPackageConfigurationByDisplayOrder() throws Exception {
    PackageConfiguration p1 = new PackageConfiguration("k1").with(PackageConfiguration.DISPLAY_ORDER, 1);
    PackageConfiguration p2 = new PackageConfiguration("k2").with(PackageConfiguration.DISPLAY_ORDER, 3);
    assertThat(p2.compareTo(p1), is(2));

  }
}

@Test
public void shouldOnlyDisplayFieldsWhichAreNonSecureAndPartOfIdentityInGetConfigForDisplayWhenPluginExists() throws Exception {
  PackageConfigurations repositoryConfiguration = new PackageConfigurations();
  repositoryConfiguration.addConfiguration(new PackageConfiguration("key1").with(PART_OF_IDENTITY, true).with(SECURE, false));
  repositoryConfiguration.addConfiguration(new PackageConfiguration("key2").with(PART_OF_IDENTITY, false).with(SECURE, false));
  repositoryConfiguration.addConfiguration(new PackageConfiguration("key3").with(PART_OF_IDENTITY, true).with(SECURE, true));
  repositoryConfiguration.addConfiguration(new PackageConfiguration("key4").with(PART_OF_IDENTITY, false).with(SECURE, true));
  repositoryConfiguration.addConfiguration(new PackageConfiguration("key5").with(PART_OF_IDENTITY, true).with(SECURE, false));
  RepositoryMetadataStore.getInstance().addMetadataFor("plugin1", repositoryConfiguration);
  Configuration configuration = new Configuration(create("key1", false, "value1"), create("key2", false, "value2"), create("key3", true, "value3"), create("key4", true, "value4"), create("key5", false, "value5"));
  PackageRepository repository = PackageRepositoryMother.create("repo1", "repo1-name", "plugin1", "1", configuration);
  assertThat(repository.getConfigForDisplay(), is("Repository: [key1=value1, key5=value5]"));
}

public PackageConfigurations(com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration packageConfiguration) {
  this.packageConfiguration = packageConfiguration;
  for (Property property : packageConfiguration.list()) {
    packageConfigurations.add(new PackageConfiguration(property));
  }
}

@Test
public void shouldConstructPackageConfigurationFromApiRepositoryConfiguration() throws Exception {
  RepositoryConfiguration configuration = new RepositoryConfiguration();
  configuration.add(new PackageMaterialProperty("k1", "v1").with(Property.SECURE, Boolean.TRUE));
  PackageConfigurations packageConfigurations = new PackageConfigurations(configuration);
  assertThat(packageConfigurations.list().size(), is(1));
  assertThat(packageConfigurations.list().get(0).getKey(), is("k1"));
  assertThat(packageConfigurations.list().get(0).getValue(), is("v1"));
  assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.REQUIRED), is(true));
  assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.PART_OF_IDENTITY), is(true));
  assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.SECURE), is(true));
  assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.DISPLAY_NAME), is(""));
  assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.DISPLAY_ORDER), is(0));
}

  @Override
  public int compareTo(Object o) {
    return this.getOption(DISPLAY_ORDER) - ((PackageConfiguration) o).getOption(DISPLAY_ORDER);
  }
}

public boolean hasOption(String pluginId, String key, Option<Boolean> option) {
  if (!isEmpty(pluginId) && hasPreferenceFor(pluginId)) {
    PackageConfigurations configurations = preferenceFor(pluginId);
    PackageConfiguration configurationForGivenKey = configurations.get(key);
    if (configurationForGivenKey != null) {
      return configurationForGivenKey.hasOption(option);
    }
  }
  return option.getValue();
}

@Test
public void shouldGetAllPackagesSortedByDisplayOrder() throws Exception {
  PackageConfiguration c1 = new PackageConfiguration("k1").with(PackageConfiguration.DISPLAY_ORDER, 2);
  PackageConfiguration c2 = new PackageConfiguration("k2").with(PackageConfiguration.DISPLAY_ORDER, 0);
  PackageConfiguration c3 = new PackageConfiguration("k3").with(PackageConfiguration.DISPLAY_ORDER, 1);
  PackageConfigurations packageConfigurations = new PackageConfigurations();
  packageConfigurations.add(c1);
  packageConfigurations.add(c2);
  packageConfigurations.add(c3);
  assertThat(packageConfigurations.list().get(0), is(c2));
  assertThat(packageConfigurations.list().get(1), is(c3));
  assertThat(packageConfigurations.list().get(2), is(c1));
}

public PackageConfigurations(RepositoryConfiguration repositoryConfiguration) {
  this.repositoryConfiguration = repositoryConfiguration;
  for (Property property : repositoryConfiguration.list()) {
    packageConfigurations.add(new PackageConfiguration(property));
  }
}

  @Test
  public void shouldConstructPackageConfigurationFromApiPackageConfiguration() throws Exception {

    com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration configuration = new com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration();
    configuration.add(new PackageMaterialProperty("k1", "v1").with(Property.SECURE, Boolean.TRUE));

    PackageConfigurations packageConfigurations = new PackageConfigurations(configuration);
    assertThat(packageConfigurations.list().size(), is(1));
    assertThat(packageConfigurations.list().get(0).getKey(), is("k1"));
    assertThat(packageConfigurations.list().get(0).getValue(), is("v1"));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.REQUIRED), is(true));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.PART_OF_IDENTITY), is(true));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.SECURE), is(true));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.DISPLAY_NAME), is(""));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.DISPLAY_ORDER), is(0));
  }
}

public boolean hasOption(Option<Boolean> option) {
  return getOption(option) == true;
}

@Test
public void shouldOnlyDisplayFieldsWhichAreNonSecureAndPartOfIdentityInGetConfigForDisplayWhenPluginExists() {
  String pluginId = "plugin-id";
  PackageConfigurations repositoryConfigurations = new PackageConfigurations();
  repositoryConfigurations.add(new PackageConfiguration("rk1", "rv1").with(PackageConfiguration.PART_OF_IDENTITY, true).with(PackageConfiguration.SECURE, false));
  repositoryConfigurations.add(new PackageConfiguration("rk2", "rv2").with(PackageConfiguration.PART_OF_IDENTITY, false).with(PackageConfiguration.SECURE, false));
  repositoryConfigurations.add(new PackageConfiguration("rk3", "rv3").with(PackageConfiguration.PART_OF_IDENTITY, true).with(PackageConfiguration.SECURE, true));
  RepositoryMetadataStore.getInstance().addMetadataFor(pluginId, repositoryConfigurations);
  PackageConfigurations packageConfigurations = new PackageConfigurations();
  packageConfigurations.add(new PackageConfiguration("pk1", "pv1").with(PackageConfiguration.PART_OF_IDENTITY, true).with(PackageConfiguration.SECURE, false));
  packageConfigurations.add(new PackageConfiguration("pk2", "pv2").with(PackageConfiguration.PART_OF_IDENTITY, false).with(PackageConfiguration.SECURE, false));
  packageConfigurations.add(new PackageConfiguration("pk3", "pv3").with(PackageConfiguration.PART_OF_IDENTITY, true).with(PackageConfiguration.SECURE, true));
  packageConfigurations.add(new PackageConfiguration("pk4", "pv4").with(PackageConfiguration.PART_OF_IDENTITY, false).with(PackageConfiguration.SECURE, true));
  packageConfigurations.add(new PackageConfiguration("pk5", "pv5").with(PackageConfiguration.PART_OF_IDENTITY, true).with(PackageConfiguration.SECURE, false));
  PackageMetadataStore.getInstance().addMetadataFor(pluginId, packageConfigurations);
  PackageRepository repository = PackageRepositoryMother.create("repo-id", "repo", pluginId, "version",
      new Configuration(create("rk1", false, "rv1"), create("rk2", false, "rv2"), create("rk3", true, "rv3")));
  Configuration packageConfig = new Configuration(create("pk1", false, "pv1"), create("pk2", false, "pv2"), create("pk3", true, "pv3"), create("pk4", true, "pv4"), create("pk5", false, "pv5"));
  PackageDefinition packageDefinition = PackageDefinitionMother.create("p-id", "name", packageConfig, repository);
  packageDefinition.setRepository(repository);
  assertThat(packageDefinition.getConfigForDisplay(), is("Repository: [rk1=rv1] - Package: [pk1=pv1, pk5=pv5]"));
}

@Test
public void shouldSetConfigAttributesForNonSecureProperty() {
  ConfigurationProperty configurationProperty = new ConfigurationProperty();
  HashMap attributes = new HashMap();
  HashMap keyMap = new HashMap();
  keyMap.put("name", "fooKey");
  attributes.put(ConfigurationProperty.CONFIGURATION_KEY, keyMap);
  HashMap valueMap = new HashMap();
  valueMap.put("value", "fooValue");
  attributes.put(ConfigurationProperty.CONFIGURATION_VALUE, valueMap);
  PackageConfigurations metadata = new PackageConfigurations();
  metadata.addConfiguration(new PackageConfiguration("fooKey", null));
  attributes.put(Configuration.METADATA, metadata);
  configurationProperty.setConfigAttributes(attributes,null);
  assertThat(configurationProperty.getConfigurationKey().getName(), is("fooKey"));
  assertThat(configurationProperty.getConfigurationValue().getValue(), is("fooValue"));
}

private void handleProperty(List<String> list, PackageConfigurations metadata, ConfigurationProperty configurationProperty) {
  PackageConfiguration packageConfiguration = null;
  if (metadata != null) {
    packageConfiguration = metadata.get(configurationProperty.getConfigurationKey().getName());
  }
  if (packageConfiguration == null || packageConfiguration.getOption(PackageConfiguration.PART_OF_IDENTITY)) {
    list.add(configurationProperty.forFingerprint());
  }
}

@Test
public void shouldAnswerIfKeyHasGivenOption() throws Exception {
  PackageConfigurations repositoryConfigurationPut = new PackageConfigurations();
  repositoryConfigurationPut.add(new PackageConfiguration("key-one").with(PackageConfiguration.SECURE, true).with(PackageConfiguration.REQUIRED, true));
  repositoryConfigurationPut.add(new PackageConfiguration("key-two"));
  RepositoryMetadataStore metadataStore = RepositoryMetadataStore.getInstance();
  metadataStore.addMetadataFor("plugin-id", repositoryConfigurationPut);
  assertThat(metadataStore.hasOption("plugin-id", "key-one", PackageConfiguration.SECURE),is(true));
  assertThat(metadataStore.hasOption("plugin-id", "key-one", PackageConfiguration.REQUIRED),is(true));
  assertThat(metadataStore.hasOption("plugin-id", "key-one", PackageConfiguration.PART_OF_IDENTITY),is(true));
  assertThat(metadataStore.hasOption("plugin-id", "key-two", PackageConfiguration.SECURE),is(false));
  assertThat(metadataStore.hasOption("plugin-id", "key-two", PackageConfiguration.REQUIRED),is(true));
  assertThat(metadataStore.hasOption("plugin-id", "key-two", PackageConfiguration.PART_OF_IDENTITY),is(true));
}

private SecureKeyInfoProvider getSecureKeyInfoProvider() {
  final RepositoryMetadataStore repositoryMetadataStore = RepositoryMetadataStore.getInstance();
  final PackageConfigurations metadata = repositoryMetadataStore.getMetadata(pluginConfiguration.getId());
  if(metadata==null){
    return null;
  }
  return key -> {
    PackageConfiguration packageConfiguration = metadata.get(key);
    return packageConfiguration.getOption(PackageConfiguration.SECURE);
  };
}

@Test
public void shouldNotConsiderPropertiesMarkedAsNotPartOfIdentity_GetFingerprint() {
  String pluginId = "plugin-id";
  PackageConfigurations repositoryConfigurations = new PackageConfigurations();
  repositoryConfigurations.add(new PackageConfiguration("rk1", "rv1").with(PackageConfiguration.PART_OF_IDENTITY, true));
  repositoryConfigurations.add(new PackageConfiguration("rk2", "rv2").with(PackageConfiguration.PART_OF_IDENTITY, false));
  RepositoryMetadataStore.getInstance().addMetadataFor(pluginId, repositoryConfigurations);
  PackageConfigurations packageConfigurations = new PackageConfigurations();
  packageConfigurations.add(new PackageConfiguration("pk1", "pv1").with(PackageConfiguration.PART_OF_IDENTITY, false));
  packageConfigurations.add(new PackageConfiguration("pk2", "pv2").with(PackageConfiguration.PART_OF_IDENTITY, true));
  PackageMetadataStore.getInstance().addMetadataFor(pluginId, packageConfigurations);
  PackageRepository repository = PackageRepositoryMother.create("repo-id", "repo", pluginId, "version",
      new Configuration(create("rk1", false, "rv1"), create("rk2", false, "rv2")));
  PackageDefinition packageDefinition = PackageDefinitionMother.create("p-id", "name",
      new Configuration(create("pk1", false, "pv1"), create("pk2", false, "pv2")), repository);
  String fingerprint = packageDefinition.getFingerprint(AbstractMaterial.FINGERPRINT_DELIMITER);
  assertThat(fingerprint, is(CachedDigestUtils.sha256Hex("plugin-id=plugin-id<|>pk2=pv2<|>rk1=rv1")));
}

private SecureKeyInfoProvider getSecureKeyInfoProvider() {
  PackageMetadataStore packageMetadataStore = PackageMetadataStore.getInstance();
  final PackageConfigurations metadata = packageMetadataStore.getMetadata(pluginId());
  if (metadata == null) {
    return null;
  }
  return key -> {
    PackageConfiguration packageConfiguration = metadata.get(key);
    return packageConfiguration.getOption(PackageConfiguration.SECURE);
  };
}