How to use

PackageMetadataStore

in

com.thoughtworks.go.plugin.access.packagematerial

private void handlePackageDefinitionProperties(List<String> list) {
  PackageConfigurations metadata = PackageMetadataStore.getInstance().getMetadata(pluginId());
  for (ConfigurationProperty configurationProperty : configuration) {
    handleProperty(list, metadata, configurationProperty);
  }
}

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

  public static void clear() {
    List<String> plugins = RepositoryMetadataStore.getInstance().getPlugins();
    for (String pluginId : plugins) {
      RepositoryMetadataStore.getInstance().removeMetadata(pluginId);
      PackageMetadataStore.getInstance().removeMetadata(pluginId);
    }
  }
}

public void applyPackagePluginMetadata(String pluginId) {
  for (ConfigurationProperty configurationProperty : configuration) {
    PackageMetadataStore packageMetadataStore = PackageMetadataStore.getInstance();
    if (packageMetadataStore.getMetadata(pluginId) != null) {
      boolean isSecureProperty = packageMetadataStore.hasOption(pluginId, configurationProperty.getConfigurationKey().getName(), PackageConfiguration.SECURE);
      configurationProperty.handleSecureValueConfiguration(isSecureProperty);
    }
  }
}

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

public void performPluginValidationsFor(final PackageDefinition packageDefinition) {
  String pluginId = packageDefinition.getRepository().getPluginConfiguration().getId();
  ValidationResult validationResult = packageRepositoryExtension.isPackageConfigurationValid(pluginId, buildPackageConfigurations(packageDefinition), buildRepositoryConfigurations(packageDefinition.getRepository()));
  for (ValidationError error : validationResult.getErrors()) {
    packageDefinition.addConfigurationErrorFor(error.getKey(), error.getMessage());
  }
  for (ConfigurationProperty configurationProperty : packageDefinition.getConfiguration()) {
    String key = configurationProperty.getConfigurationKey().getName();
    if (PackageMetadataStore.getInstance().hasOption(packageDefinition.getRepository().getPluginConfiguration().getId(), key, PackageConfiguration.REQUIRED)) {
      if (configurationProperty.getValue().isEmpty() && configurationProperty.doesNotHaveErrorsAgainstConfigurationValue()) {
        configurationProperty.addErrorAgainstConfigurationValue("Field: '" + configurationProperty.getConfigurationKey().getName() + "' is required");
      }
    }
  }
}

public void addConfigurations(List<ConfigurationProperty> configurations) {
  ConfigurationPropertyBuilder builder = new ConfigurationPropertyBuilder();
  for (ConfigurationProperty property : configurations) {
    if (doesPluginExist()) {
      com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration packageMetadata = PackageMetadataStore.getInstance().getPackageMetadata(pluginId());
      if (isValidConfiguration(property.getConfigKeyName(), packageMetadata)) {
        configuration.add(builder.create(property.getConfigKeyName(), property.getConfigValue(), property.getEncryptedValue(), packagePropertyFor(property.getConfigKeyName(), packageMetadata).getOption(Property.SECURE)));
      } else {
        configuration.add(property);
      }
    } else {
      configuration.add(property);
    }
  }
}

public String getConfigForDisplay() {
  AbstractMetaDataStore metadataStore = PackageMetadataStore.getInstance();
  List<ConfigurationProperty> propertiesToBeUsedForDisplay = ConfigurationDisplayUtil.getConfigurationPropertiesToBeUsedForDisplay(metadataStore, pluginId(), configuration);
  return format("%s - Package: %s", getRepository().getConfigForDisplay(), configuration.forDisplay(propertiesToBeUsedForDisplay));
}

  public static void clearSingletons() {
    AnalyticsMetadataStore.instance().clear();
    ArtifactMetadataStore.instance().clear();
    AuthorizationMetadataStore.instance().clear();
    ConfigRepoMetadataStore.instance().clear();
    ElasticAgentMetadataStore.instance().clear();
    NewSCMMetadataStore.instance().clear();
    NotificationMetadataStore.instance().clear();
    PackageMaterialMetadataStore.instance().clear();
    PluggableTaskMetadataStore.instance().clear();

    new CachingSubjectDnX509PrincipalExtractor().getCache().removeAll();

    //
    SessionUtils.unsetCurrentUser();

    //
    PackageMetadataStore.getInstance().clear();
    PluggableTaskConfigStore.store().clear();
    PluginSettingsMetadataStore.getInstance().clear();
    RepositoryMetadataStore.getInstance().clear();
    SCMMetadataStore.getInstance().clear();
  }
}

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

  public com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration getPackageMetadata(String pluginId) {

    PackageConfigurations metadata = packageMetadataStore.getMetadata(pluginId);
    if (metadata != null) {
      return metadata.getPackageConfiguration();
    }
    return null;
  }
}

  @Override
  public void pluginUnLoaded(GoPluginDescriptor pluginDescriptor) {
    repositoryMetadataStore.removeMetadata(pluginDescriptor.id());
    packageMetadataStore.removeMetadata(pluginDescriptor.id());
  }
}

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

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

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

  public static void clear() {
    List<String> plugins = RepositoryMetadataStore.getInstance().getPlugins();
    for (String pluginId : plugins) {
      RepositoryMetadataStore.getInstance().removeMetadata(pluginId);
      PackageMetadataStore.getInstance().removeMetadata(pluginId);
    }
  }
}

@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 shouldThrowExceptionWhenNullRepositoryConfigurationReturned() {
  when(packageRepositoryExtension.getRepositoryConfiguration(pluginDescriptor.id())).thenReturn(null);
  try {
    metadataLoader.fetchRepositoryAndPackageMetaData(pluginDescriptor);
  } catch (Exception e) {
    assertThat(e.getMessage(), is("Plugin[plugin-id] returned null repository configuration"));
  }
  assertThat(RepositoryMetadataStore.getInstance().getMetadata(pluginDescriptor.id()), nullValue());
  assertThat(PackageMetadataStore.getInstance().getMetadata(pluginDescriptor.id()), nullValue());
}