@Override public ClassLoaderModel build() { Optional<Plugin> pluginOptional = empty(); if (processSharedLibraries || processAdditionalPluginLibraries) { pluginOptional = findMuleMavenPluginDeclaration(); } if (processSharedLibraries) { pluginOptional.ifPresent(this::exportSharedLibrariesResourcesAndPackages); } if (processAdditionalPluginLibraries) { pluginOptional.ifPresent(this::processAdditionalPluginLibraries); } return super.build(); }
@Test public void sanitizesExportedResources() { Set<String> exportedResources = new HashSet<>(); exportedResources.add("META-INF\\schemas\\schema.xml"); exportedResources.add("META-INF\\README.txt"); ClassLoaderModel classLoaderModel = new ClassLoaderModel.ClassLoaderModelBuilder().exportingResources(exportedResources).build(); assertThat(classLoaderModel.getExportedResources(), containsInAnyOrder("META-INF/schemas/schema.xml", "META-INF/README.txt")); } }
private void sanitizeExportedPackages(ArtifactPluginDescriptor pluginDescriptor, List<ArtifactPluginDescriptor> resolvedPlugins) { final Set<String> packagesExportedByDependencies = findDependencyPackageClosure(pluginDescriptor.getClassLoaderModel().getDependencies(), resolvedPlugins); ClassLoaderModel originalClassLoaderModel = pluginDescriptor.getClassLoaderModel(); final Set<String> exportedClassPackages = new HashSet<>(originalClassLoaderModel.getExportedPackages()); exportedClassPackages.removeAll(packagesExportedByDependencies); pluginDescriptor.setClassLoaderModel(createBuilderWithoutExportedPackages(originalClassLoaderModel) .exportingPackages(exportedClassPackages).build()); }
@Test public void resolvesPluginWithNewestVersionOnDependency() throws Exception { final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(barPlugin, bazPlugin, fooPlugin); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(LATEST_BAZ_PLUGIN_DESCRIPTOR)).build()); bazPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(FOO_PLUGIN_DESCRIPTOR)).build()); latestBazPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(FOO_PLUGIN_DESCRIPTOR)).build()); when(artifactDescriptorFactory .create(argThat(hasProperty("absolutePath", endsWith(latestBazPlugin.getBundleDescriptor().getArtifactFileName()))), any(Optional.class))).thenReturn(latestBazPlugin); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, fooPlugin, bazPlugin, barPlugin); }
@Test public void resolvesSnapshotPluginDependencyWithCompatibleMinorVersion() throws Exception { ArtifactPluginDescriptor updatedFooPlugin = new ArtifactPluginDescriptor(FOO_PLUGIN); updatedFooPlugin.setBundleDescriptor(createTestBundleDescriptor(FOO_PLUGIN, "1.1")); final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(updatedFooPlugin, barPlugin); BundleDescriptor fooBundleDescriptor = createTestBundleDescriptor(FOO_PLUGIN, "1.0-SNAPSHOT"); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder() .dependingOn(singleton(createBundleDependency(fooBundleDescriptor))).build()); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, updatedFooPlugin, barPlugin); }
@Test(expected = PluginResolutionError.class) public void doesNotResolvesPluginDependencyWithIncompatibleMinorVersion() throws Exception { ArtifactPluginDescriptor majorUpdatedFooPlugin = new ArtifactPluginDescriptor(FOO_PLUGIN); majorUpdatedFooPlugin.setBundleDescriptor(createTestBundleDescriptor(FOO_PLUGIN, "1.1")); final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(fooPlugin, barPlugin); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder() .dependingOn(singleton(createBundleDependency(majorUpdatedFooPlugin.getBundleDescriptor()))).build()); dependenciesResolver.resolve(emptySet(), pluginDescriptors, true); }
@Test public void resolvesPluginDependencyWithSnapshotMinorVersion() throws Exception { ArtifactPluginDescriptor updatedFooPlugin = new ArtifactPluginDescriptor(FOO_PLUGIN); updatedFooPlugin.setBundleDescriptor(createTestBundleDescriptor(FOO_PLUGIN, "1.1-SNAPSHOT")); final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(updatedFooPlugin, barPlugin); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder() .dependingOn(singleton(createBundleDependency(FOO_BUNDLE_DESCRIPTOR))).build()); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, updatedFooPlugin, barPlugin); }
private ClassLoaderModel createClassLoaderModelWithDomain() { BundleDescriptor domainDescriptor = new BundleDescriptor.Builder().setArtifactId(DOMAIN_NAME).setGroupId("test") .setVersion("1.0.0").setClassifier(MULE_DOMAIN_CLASSIFIER).build(); Set<BundleDependency> domainDependency = Collections.singleton(new BundleDependency.Builder().setDescriptor(domainDescriptor).build()); return new ClassLoaderModel.ClassLoaderModelBuilder().dependingOn(domainDependency).build(); }
@Test public void sanitizesDependantPluginExportedPackages() throws Exception { fooPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().exportingPackages(getFooExportedPackages()).build()); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(FOO_PLUGIN_DESCRIPTOR)) .exportingPackages(getBarExportedPackages()).build()); final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(fooPlugin, barPlugin); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, fooPlugin, barPlugin); assertPluginExportedPackages(fooPlugin, "org.foo", "org.foo.mule"); assertPluginExportedPackages(barPlugin, "org.bar", "org.baz", "org.bar.mule"); }
@Test(expected = PluginResolutionError.class) public void doesNotResolvesPluginDependencyWithIncompatibleMajorVersion() throws Exception { ArtifactPluginDescriptor majorUpdatedFooPlugin = new ArtifactPluginDescriptor(FOO_PLUGIN); majorUpdatedFooPlugin.setBundleDescriptor(createTestBundleDescriptor(FOO_PLUGIN, "2.0")); final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(majorUpdatedFooPlugin, barPlugin); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder() .dependingOn(singleton(createBundleDependency(FOO_BUNDLE_DESCRIPTOR))).build()); dependenciesResolver.resolve(emptySet(), pluginDescriptors, true); }
@Test public void resolvesPluginDependencyWithCompatibleMinorVersion() throws Exception { ArtifactPluginDescriptor updatedFooPlugin = new ArtifactPluginDescriptor(FOO_PLUGIN); updatedFooPlugin.setBundleDescriptor(createTestBundleDescriptor(FOO_PLUGIN, "1.1")); final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(updatedFooPlugin, barPlugin); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder() .dependingOn(singleton(createBundleDependency(FOO_BUNDLE_DESCRIPTOR))).build()); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, updatedFooPlugin, barPlugin); }
@Test public void resolvesPluginDisorderedDependency() throws Exception { final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(barPlugin, fooPlugin); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(FOO_PLUGIN_DESCRIPTOR)).build()); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, fooPlugin, barPlugin); }
@Test public void verifiesPolicyTemplateDoesNotExportPackages() throws Exception { PolicyTemplateDescriptor policyTemplateDescriptor = new PolicyTemplateDescriptor(POLICY_NAME); ClassLoaderModel classLoaderModel = new ClassLoaderModel.ClassLoaderModelBuilder().exportingPackages(Collections.singleton("org.foo")).build(); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(POLICY_EXPORTED_PACKAGES_ERROR); policyTemplateDescriptor.setClassLoaderModel(classLoaderModel); }
@Test public void resolvesMultipleDependencies() throws Exception { final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(bazPlugin, barPlugin, fooPlugin); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(BAZ_PLUGIN_DESCRIPTOR)).build()); bazPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(FOO_PLUGIN_DESCRIPTOR)).build()); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, fooPlugin, bazPlugin, barPlugin); }
@Test public void resolvesTransitiveDependencies() throws Exception { final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(fooPlugin, barPlugin, bazPlugin); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(BAZ_PLUGIN_DESCRIPTOR)).build()); bazPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(FOO_PLUGIN_DESCRIPTOR)).build()); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, fooPlugin, bazPlugin, barPlugin); }
@Test public void detectsDuplicateExportedPackagesOnIndependentPlugins() throws Exception { fooPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().exportingPackages(getFooExportedPackages()).build()); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().exportingPackages(getBarExportedPackages()).build()); final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(fooPlugin, barPlugin); Map<String, List<String>> pluginsPerPackage = new HashMap<>(); pluginsPerPackage.put("org.foo", asList("bar, foo")); pluginsPerPackage.put("org.foo.mule", asList("bar, foo")); String expectedErrorMessage = new DuplicateExportedPackageException(pluginsPerPackage).getMessage(); this.expectedException.expect(DuplicateExportedPackageException.class); this.expectedException.expectMessage(expectedErrorMessage); dependenciesResolver.resolve(emptySet(), pluginDescriptors, true); }
@Test public void resolvesDependenciesTwoVersionWhenLatestComesFromTransitiveMinor() throws Exception { final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(fooPlugin, latestEchoPlugin, bazPlugin); latestEchoPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(BAZ_PLUGIN_DESCRIPTOR)).build()); fooPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(ECHO_PLUGIN_DESCRIPTOR)).build()); echoPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(LATEST_BAZ_PLUGIN_DESCRIPTOR)).build()); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, bazPlugin, latestEchoPlugin, fooPlugin); }
@Test public void detectsUnresolvablePluginDependency() throws Exception { final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(fooPlugin); fooPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(BAR_PLUGIN_DESCRIPTOR)).build()); expectedException.expect(PluginResolutionError.class); expectedException.expectMessage(format(DEPENDENCY_PROVIDER_ERROR_MESSAGE, BAR_BUNDLE_DESCRIPTOR)); dependenciesResolver.resolve(emptySet(), pluginDescriptors, true); }
@Test public void resolvesPluginOrderedDependency() throws Exception { final List<ArtifactPluginDescriptor> pluginDescriptors = createPluginDescriptors(fooPlugin, barPlugin); barPlugin.setClassLoaderModel(new ClassLoaderModelBuilder().dependingOn(singleton(FOO_PLUGIN_DESCRIPTOR)).build()); final List<ArtifactPluginDescriptor> resolvedPluginDescriptors = dependenciesResolver.resolve( emptySet(), pluginDescriptors, true); assertResolvedPlugins(resolvedPluginDescriptors, fooPlugin, barPlugin); }
@Test public void verifiesPolicyTemplateDoesNotExportResources() throws Exception { PolicyTemplateDescriptor policyTemplateDescriptor = new PolicyTemplateDescriptor(POLICY_NAME); ClassLoaderModel classLoaderModel = new ClassLoaderModel.ClassLoaderModelBuilder().exportingResources(Collections.singleton("META-INF/foo.xml")).build(); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(POLICY_EXPORTED_RESOURCE_ERROR); policyTemplateDescriptor.setClassLoaderModel(classLoaderModel); } }