How to use

addMetadataFor

method

in

com.thoughtworks.go.plugin.access.packagematerial.PackageMetadataStore

void fetchRepositoryAndPackageMetaData(GoPluginDescriptor pluginDescriptor) {
  try {
    RepositoryConfiguration repositoryConfiguration = packageRepositoryExtension.getRepositoryConfiguration(pluginDescriptor.id());
    com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration packageConfiguration = packageRepositoryExtension.getPackageConfiguration(pluginDescriptor.id());
    if (repositoryConfiguration == null) {
      throw new RuntimeException(format("Plugin[%s] returned null repository configuration", pluginDescriptor.id()));
    }
    if (packageConfiguration == null) {
      throw new RuntimeException(format("Plugin[%s] returned null package configuration", pluginDescriptor.id()));
    }
    repositoryMetadataStore.addMetadataFor(pluginDescriptor.id(), new PackageConfigurations(repositoryConfiguration));
    packageMetadataStore.addMetadataFor(pluginDescriptor.id(), new PackageConfigurations(packageConfiguration));
  } catch (GoPluginFrameworkException e) {
    LOGGER.error("Failed to fetch package metadata for plugin : {}", pluginDescriptor.id(), e);
  }
}

  @Test
  public void shouldBeAbleToCheckIfPluginExists() throws Exception {
    PackageMetadataStore metadataStore = PackageMetadataStore.getInstance();

    PackageConfigurations packageConfigurations = new PackageConfigurations();
    metadataStore.addMetadataFor("plugin-id", packageConfigurations);

    assertThat(metadataStore.hasPlugin("plugin-id"), is(true));
    assertThat(metadataStore.hasPlugin("some-plugin-which-does-not-exist"), is(false));
  }
}

@Test
public void shouldPopulateDataCorrectly() throws Exception {
  PackageConfigurations packageConfigurations = new PackageConfigurations();
  PackageMetadataStore.getInstance().addMetadataFor("plugin-id", packageConfigurations);
  assertThat(PackageMetadataStore.getInstance().getMetadata("plugin-id"), is(packageConfigurations));
}

  @Test
  public void shouldRemoveMetadataOnPluginUnLoadedCallback() throws Exception {
    RepositoryMetadataStore.getInstance().addMetadataFor(pluginDescriptor.id(), new PackageConfigurations());
    PackageMetadataStore.getInstance().addMetadataFor(pluginDescriptor.id(), new PackageConfigurations());
    when(packageRepositoryExtension.canHandlePlugin(pluginDescriptor.id())).thenReturn(true);
    metadataLoader.pluginUnLoaded(pluginDescriptor);
    assertThat(RepositoryMetadataStore.getInstance().getMetadata(pluginDescriptor.id()), is(nullValue()));
    assertThat(PackageMetadataStore.getInstance().getMetadata(pluginDescriptor.id()), is(nullValue()));
  }
}

@Test
public void shouldReturnSomethingMoreSaneForToString() throws Exception {
  PackageMaterial material = MaterialsMother.packageMaterial();
  RepositoryMetadataStore.getInstance().addMetadataFor(material.getPluginId(), new PackageConfigurations());
  PackageMetadataStore.getInstance().addMetadataFor(material.getPluginId(), new PackageConfigurations());
  assertThat(material.toString(), is("'PackageMaterial{Repository: [k1=repo-v1, k2=repo-v2] - Package: [k3=package-v1]}'"));
}

@Test
public void shouldConvertKeysToLowercaseInGetConfigForDisplay() throws Exception {
  RepositoryMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  PackageMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  Configuration configuration = new Configuration(create("kEY1", false, "vALue1"), create("KEY_MORE_2", false, "VALUE_2"), create("key_3", false, "value3"));
  PackageRepository repository = PackageRepositoryMother.create("repo1", "repo1-name", "some-plugin", "1", configuration);
  assertThat(repository.getConfigForDisplay(), is("Repository: [key1=vALue1, key_more_2=VALUE_2, key_3=value3]"));
}

@Test
public void shouldNotDisplayEmptyValuesInGetConfigForDisplay() throws Exception {
  RepositoryMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  PackageMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  Configuration configuration = new Configuration(create("rk1", false, ""), create("rk2", false, "some-non-empty-value"), create("rk3", false, null));
  PackageRepository repository = PackageRepositoryMother.create("repo-id", "repo", "some-plugin", "version", configuration);
  assertThat(repository.getConfigForDisplay(), is("Repository: [rk2=some-non-empty-value]"));
}

@Test
public void shouldConvertKeysToLowercaseInGetConfigForDisplay() throws Exception {
  RepositoryMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  PackageMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  PackageRepository repository = PackageRepositoryMother.create("repo-id", "repo", "some-plugin", "version", new Configuration(create("rk1", false, "rv1")));
  PackageDefinition packageDefinition = PackageDefinitionMother.create("p-id", "name",
      new Configuration(create("pack_key_1", false, "pack_value_1"), create("PACK_KEY_2", false, "PACK_VALUE_2"), create("pacK_KeY3", false, "pacKValue_3")), repository);
  packageDefinition.setRepository(repository);
  assertThat(packageDefinition.getConfigForDisplay(), is("Repository: [rk1=rv1] - Package: [pack_key_1=pack_value_1, pack_key_2=PACK_VALUE_2, pack_key3=pacKValue_3]"));
}

@Test
public void shouldNotDisplayEmptyValuesInGetConfigForDisplay() throws Exception {
  RepositoryMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  PackageMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  PackageRepository repository = PackageRepositoryMother.create("repo-id", "repo", "some-plugin", "version", new Configuration(create("rk1", false, "rv1")));
  PackageDefinition packageDefinition = PackageDefinitionMother.create("p-id", "name",
      new Configuration(create("pk1", false, ""), create("pk2", false, "pack_value_2"), create("pk3", false, null)), repository);
  packageDefinition.setRepository(repository);
  assertThat(packageDefinition.getConfigForDisplay(), is("Repository: [rk1=rv1] - Package: [pk2=pack_value_2]"));
}

@Test
public void shouldGetUriForDisplay() {
  RepositoryMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  PackageMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations());
  PackageMaterial material = new PackageMaterial();
  Configuration configuration = new Configuration(ConfigurationPropertyMother.create("k1", false, "repo-v1"), ConfigurationPropertyMother.create("k2", false, "repo-v2"));
  PackageRepository repository = PackageRepositoryMother.create("repo-id", "repo-name", "some-plugin", "version", configuration);
  PackageDefinition packageDefinition = PackageDefinitionMother.create("p-id", "package-name", new Configuration(ConfigurationPropertyMother.create("k3", false, "package-v1")), repository);
  material.setPackageDefinition(packageDefinition);
  assertThat(material.getUriForDisplay(), is("Repository: [k1=repo-v1, k2=repo-v2] - Package: [k3=package-v1]"));
}

@Test
public void shouldSetConfigAttributes() throws Exception {
  PackageDefinition definition = new PackageDefinition();
  String pluginId = "plugin";
  Map config = createPackageDefinitionConfiguration("package-name", pluginId, new ConfigurationHolder("key1", "value1"), new ConfigurationHolder("key2", "value2", "encrypted-value", true, "1"),
      new ConfigurationHolder("key3", "test", "encrypted-value", true, "0"));
  PackageConfigurations metadata = new PackageConfigurations();
  metadata.addConfiguration(new PackageConfiguration("key1"));
  metadata.addConfiguration(new PackageConfiguration("key2").with(PackageConfiguration.SECURE, true));
  metadata.addConfiguration(new PackageConfiguration("key3").with(PackageConfiguration.SECURE, true));
  PackageMetadataStore.getInstance().addMetadataFor(pluginId, metadata);
  definition.setRepository(PackageRepositoryMother.create("1"));
  definition.setConfigAttributes(config);
  String encryptedValue = new GoCipher().encrypt("value2");
  assertThat(definition.getName(), is("package-name"));
  assertThat(definition.getConfiguration().size(), is(3));
  assertThat(definition.getConfiguration().getProperty("key1").getConfigurationValue().getValue(), is("value1"));
  assertThat(definition.getConfiguration().getProperty("key1").getEncryptedConfigurationValue(), is(nullValue()));
  assertThat(definition.getConfiguration().getProperty("key2").getEncryptedValue(), is(encryptedValue));
  assertThat(definition.getConfiguration().getProperty("key2").getConfigurationValue(), is(nullValue()));
  assertThat(definition.getConfiguration().getProperty("key3").getEncryptedValue(), is("encrypted-value"));
  assertThat(definition.getConfiguration().getProperty("key3").getConfigurationValue(), is(nullValue()));
}

@Test
public void shouldFailValidationIfMaterialWithDuplicateFingerprintIsFound() {
  com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration packageConfiguration = new com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration();
  packageConfiguration.add(new PackageMaterialProperty("k1"));
  packageConfiguration.add(new PackageMaterialProperty("k2").with(PART_OF_IDENTITY, false));
  PackageMetadataStore.getInstance().addMetadataFor("plugin", new PackageConfigurations(packageConfiguration));
  String expectedErrorMessage = "Cannot save package or repo, found duplicate packages. [Repo Name: 'repo-repo1', Package Name: 'pkg1'], [Repo Name: 'repo-repo1', Package Name: 'pkg3'], [Repo Name: 'repo-repo1', Package Name: 'pkg5']";
  PackageRepository repository = PackageRepositoryMother.create("repo1");
  PackageDefinition definition1 = PackageDefinitionMother.create("1", "pkg1", new Configuration(new ConfigurationProperty(new ConfigurationKey("k1"), new ConfigurationValue("v1"))), repository);
  PackageDefinition definition2 = PackageDefinitionMother.create("2", "pkg2", new Configuration(new ConfigurationProperty(new ConfigurationKey("k1"), new ConfigurationValue("v2"))), repository);
  PackageDefinition definition3 = PackageDefinitionMother.create("3", "pkg3", new Configuration(new ConfigurationProperty(new ConfigurationKey("k1"), new ConfigurationValue("v1"))), repository);
  PackageDefinition definition4 = PackageDefinitionMother.create("4", "pkg4", new Configuration(new ConfigurationProperty(new ConfigurationKey("k1"), new ConfigurationValue("V1"))), repository);
  PackageDefinition definition5 = PackageDefinitionMother.create("5", "pkg5", new Configuration(new ConfigurationProperty(new ConfigurationKey("k1"), new ConfigurationValue("v1")), new ConfigurationProperty(new ConfigurationKey("k2"), new ConfigurationValue("v2"))), repository);
  repository.setPackages(new Packages(definition1, definition2, definition3, definition4, definition5));
  PackageRepositories packageRepositories = new PackageRepositories(repository);
  packageRepositories.validate(null);
  assertThat(definition1.errors().getAllOn(PackageDefinition.ID), is(asList(expectedErrorMessage)));
  assertThat(definition3.errors().getAllOn(PackageDefinition.ID), is(asList(expectedErrorMessage)));
  assertThat(definition3.getFingerprint(AbstractMaterialConfig.FINGERPRINT_DELIMITER).equals(definition1.getFingerprint(AbstractMaterialConfig.FINGERPRINT_DELIMITER)), is(true));
  assertThat(definition5.errors().getAllOn(PackageDefinition.ID), is(asList(expectedErrorMessage)));
  assertThat(definition5.getFingerprint(AbstractMaterialConfig.FINGERPRINT_DELIMITER).equals(definition1.getFingerprint(AbstractMaterialConfig.FINGERPRINT_DELIMITER)), is(true));
  assertThat(definition2.errors().getAllOn(PackageDefinition.ID), is(nullValue()));
  assertThat(definition2.getFingerprint(AbstractMaterialConfig.FINGERPRINT_DELIMITER).equals(definition1.getFingerprint(AbstractMaterialConfig.FINGERPRINT_DELIMITER)), is(false));
  assertThat(definition4.errors().getAllOn(PackageDefinition.ID), is(nullValue()));
  assertThat(definition4.getFingerprint(AbstractMaterialConfig.FINGERPRINT_DELIMITER).equals(definition1.getFingerprint(AbstractMaterialConfig.FINGERPRINT_DELIMITER)), is(false));
}

@Test
public void shouldGetFingerprint() {
  String pluginId = "pluginid";
  PackageConfigurations repositoryConfigurations = new PackageConfigurations();
  repositoryConfigurations.add(new PackageConfiguration("k1", "v1").with(PackageConfiguration.PART_OF_IDENTITY, true));
  RepositoryMetadataStore.getInstance().addMetadataFor(pluginId, repositoryConfigurations);
  PackageConfigurations packageConfigurations = new PackageConfigurations();
  packageConfigurations.add(new PackageConfiguration("k2", "v2").with(PackageConfiguration.PART_OF_IDENTITY, true));
  PackageMetadataStore.getInstance().addMetadataFor(pluginId, packageConfigurations);
  PackageRepository repository = PackageRepositoryMother.create("repo-id", "repo", pluginId, "version", new Configuration(create("k1", false, "v1")));
  PackageDefinition packageDefinition = PackageDefinitionMother.create("p-id", "name", new Configuration(create("k2", false, "v2")), repository);
  String fingerprint = packageDefinition.getFingerprint(AbstractMaterial.FINGERPRINT_DELIMITER);
  assertThat(fingerprint, is(CachedDigestUtils.sha256Hex("plugin-id=pluginid<|>k2=v2<|>k1=v1")));
}

packageConfigurations.addConfiguration(new PackageConfiguration("key1").with(SECURE, true));
packageConfigurations.addConfiguration(new PackageConfiguration("key2").with(SECURE, false));
PackageMetadataStore.getInstance().addMetadataFor("plugin-id", packageConfigurations);

@Test
public void shouldMakeConfigurationSecureBasedOnMetadata() throws Exception {
  /*secure property is set based on metadata*/
  ConfigurationProperty secureProperty = new ConfigurationProperty(new ConfigurationKey("key1"), new ConfigurationValue("value1"), null, new GoCipher());
  ConfigurationProperty nonSecureProperty = new ConfigurationProperty(new ConfigurationKey("key2"), new ConfigurationValue("value2"), null, new GoCipher());
  PackageDefinition packageDefinition = new PackageDefinition("go", "name", new Configuration(secureProperty, nonSecureProperty));
  PackageRepository packageRepository = new PackageRepository();
  packageRepository.setPluginConfiguration(new PluginConfiguration("plugin-id", "1.0"));
  packageDefinition.setRepository(packageRepository);
  PackageConfigurations packageConfigurations = new PackageConfigurations();
  packageConfigurations.addConfiguration(new PackageConfiguration("key1").with(PackageConfiguration.SECURE, true));
  packageConfigurations.addConfiguration(new PackageConfiguration("key2").with(PackageConfiguration.SECURE, false));
  PackageMetadataStore.getInstance().addMetadataFor("plugin-id", packageConfigurations);
  packageDefinition.applyPackagePluginMetadata("plugin-id");
  assertThat(secureProperty.isSecure(), is(true));
  assertThat(nonSecureProperty.isSecure(), is(false));
}

@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")));
}

packageConfigurations.addConfiguration(new PackageConfiguration("secure-one").with(PackageConfiguration.SECURE, true));
packageConfigurations.addConfiguration(new PackageConfiguration("secure-two").with(PackageConfiguration.SECURE, true));
PackageMetadataStore.getInstance().addMetadataFor("plugin-id", packageConfigurations);
RepositoryMetadataStore.getInstance().addMetadataFor("plugin-id", packageConfigurations);

repositoryConfiguration.add(new PackageMaterialProperty("REPO-KEY2").with(REQUIRED, false).with(PART_OF_IDENTITY, false));
repositoryConfiguration.add(new PackageMaterialProperty("REPO-KEY3").with(REQUIRED, false).with(PART_OF_IDENTITY, false).with(SECURE, true));
PackageMetadataStore.getInstance().addMetadataFor("plugin-1", new PackageConfigurations(packageConfiguration));
RepositoryMetadataStore.getInstance().addMetadataFor("plugin-1", new PackageConfigurations(repositoryConfiguration));

@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]"));
}