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 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)); }
@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")); }
@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)); }
@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)); }
@Test public void shouldFetchPackageMetadataForPluginsWhichImplementPackageRepositoryMaterialExtensionPoint() { RepositoryConfiguration expectedRepoConfigurations = new RepositoryConfiguration(); com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration expectedPackageConfigurations = new PackageConfiguration(); when(packageRepositoryExtension.getRepositoryConfiguration(pluginDescriptor.id())).thenReturn(expectedRepoConfigurations); when(packageRepositoryExtension.getPackageConfiguration(pluginDescriptor.id())).thenReturn(expectedPackageConfigurations); metadataLoader.fetchRepositoryAndPackageMetaData(pluginDescriptor); assertThat(RepositoryMetadataStore.getInstance().getMetadata(pluginDescriptor.id()).getRepositoryConfiguration(), is(expectedRepoConfigurations)); assertThat(PackageMetadataStore.getInstance().getMetadata(pluginDescriptor.id()).getPackageConfiguration(), is(expectedPackageConfigurations)); }
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(); }
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; } }
public RepositoryConfiguration getRepositoryMetadata(String pluginId) { PackageConfigurations metadata = repositoryMetadataStore.getMetadata(pluginId); if (metadata != null) { return metadata.getRepositoryConfiguration(); } return null; } }
@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"))); }
@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)); } }
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 shouldGetAllPluginIds() throws Exception { RepositoryMetadataStore metadataStore = RepositoryMetadataStore.getInstance(); metadataStore.addMetadataFor("plugin1", new PackageConfigurations()); metadataStore.addMetadataFor("plugin2", new PackageConfigurations()); metadataStore.addMetadataFor("plugin3", new PackageConfigurations()); assertThat(metadataStore.getPlugins().size(), is(3)); assertThat(metadataStore.getPlugins().contains("plugin1"), is(true)); assertThat(metadataStore.getPlugins().contains("plugin2"), is(true)); assertThat(metadataStore.getPlugins().contains("plugin3"), is(true)); }
@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]")); }
@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() { 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 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 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 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]")); }
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); }; }