/** * Build an artifact from the specified plugin classes and then add it. The * jar created will include all classes in the same package as the give classes, plus any dependencies of the * given classes. If another plugin in the same package as the given plugin requires a different set of dependent * classes, you must include both plugins. For example, suppose you have two plugins, * com.company.myapp.functions.functionX and com.company.myapp.function.functionY, with functionX having * one set of dependencies and functionY having another set of dependencies. If you only add functionX, functionY * will also be included in the created jar since it is in the same package. However, only functionX's dependencies * will be traced and added to the jar, so you will run into issues when the platform tries to register functionY. * In this scenario, you must be certain to include specify both functionX and functionY when calling this method. * * @param artifactId the id of the artifact to add * @param parent the parent artifact it extends * @param pluginClass the plugin class to build the jar from * @param pluginClasses any additional plugin classes that should be included in the jar * @return {@link ArtifactManager} to manage the added plugin artifact */ protected static ArtifactManager addPluginArtifact(ArtifactId artifactId, ArtifactId parent, Class<?> pluginClass, Class<?>... pluginClasses) throws Exception { return getTestManager().addPluginArtifact(artifactId, parent, pluginClass, pluginClasses); }
/** * Build an artifact from the specified plugin classes and then add it. The * jar created will include all classes in the same package as the give classes, plus any dependencies of the * given classes. If another plugin in the same package as the given plugin requires a different set of dependent * classes, you must include both plugins. For example, suppose you have two plugins, * com.company.myapp.functions.functionX and com.company.myapp.function.functionY, with functionX having * one set of dependencies and functionY having another set of dependencies. If you only add functionX, functionY * will also be included in the created jar since it is in the same package. However, only functionX's dependencies * will be traced and added to the jar, so you will run into issues when the platform tries to register functionY. * In this scenario, you must be certain to include specify both functionX and functionY when calling this method. * * @param artifactId the id of the artifact to add * @param parent the parent artifact it extends * @param additionalPlugins any plugin classes that need to be explicitly declared because they cannot be found * by inspecting the jar. This is true for 3rd party plugins, such as jdbc drivers * @param pluginClass the plugin class to build the jar from * @param pluginClasses any additional plugin classes that should be included in the jar * @return an {@link ArtifactManager} to manage the added plugin artifact */ protected static ArtifactManager addPluginArtifact(ArtifactId artifactId, ArtifactId parent, Set<PluginClass> additionalPlugins, Class<?> pluginClass, Class<?>... pluginClasses) throws Exception { return getTestManager().addPluginArtifact(artifactId, parent, additionalPlugins, pluginClass, pluginClasses); }
/** * Build an artifact from the specified plugin classes and then add it. The * jar created will include all classes in the same package as the give classes, plus any dependencies of the * given classes. If another plugin in the same package as the given plugin requires a different set of dependent * classes, you must include both plugins. For example, suppose you have two plugins, * com.company.myapp.functions.functionX and com.company.myapp.function.functionY, with functionX having * one set of dependencies and functionY having another set of dependencies. If you only add functionX, functionY * will also be included in the created jar since it is in the same package. However, only functionX's dependencies * will be traced and added to the jar, so you will run into issues when the platform tries to register functionY. * In this scenario, you must be certain to include specify both functionX and functionY when calling this method. * * @param artifactId the id of the artifact to add * @param parent the parent artifact it extends * @param additionalPlugins any plugin classes that need to be explicitly declared because they cannot be found * by inspecting the jar. This is true for 3rd party plugins, such as jdbc drivers * @param pluginClass the plugin class to build the jar from * @param pluginClasses any additional plugin classes that should be included in the jar * @return an {@link ArtifactManager} to manage the added plugin artifact */ protected static ArtifactManager addPluginArtifact(ArtifactId artifactId, ArtifactId parent, Set<PluginClass> additionalPlugins, Class<?> pluginClass, Class<?>... pluginClasses) throws Exception { return getTestManager().addPluginArtifact(artifactId, parent, additionalPlugins, pluginClass, pluginClasses); }
/** * Build an artifact from the specified plugin classes and then add it. The * jar created will include all classes in the same package as the give classes, plus any dependencies of the * given classes. If another plugin in the same package as the given plugin requires a different set of dependent * classes, you must include both plugins. For example, suppose you have two plugins, * com.company.myapp.functions.functionX and com.company.myapp.function.functionY, with functionX having * one set of dependencies and functionY having another set of dependencies. If you only add functionX, functionY * will also be included in the created jar since it is in the same package. However, only functionX's dependencies * will be traced and added to the jar, so you will run into issues when the platform tries to register functionY. * In this scenario, you must be certain to include specify both functionX and functionY when calling this method. * * @param artifactId the id of the artifact to add * @param parentArtifacts the parent artifacts it extends * @param pluginClass the plugin class to build the jar from * @param pluginClasses any additional plugin classes that should be included in the jar * @return an {@link ArtifactManager} to manage the added plugin artifact */ protected static ArtifactManager addPluginArtifact(ArtifactId artifactId, Set<ArtifactRange> parentArtifacts, Class<?> pluginClass, Class<?>... pluginClasses) throws Exception { return getTestManager().addPluginArtifact(artifactId, parentArtifacts, pluginClass, pluginClasses); }
/** * Build an artifact from the specified plugin classes and then add it. The * jar created will include all classes in the same package as the give classes, plus any dependencies of the * given classes. If another plugin in the same package as the given plugin requires a different set of dependent * classes, you must include both plugins. For example, suppose you have two plugins, * com.company.myapp.functions.functionX and com.company.myapp.function.functionY, with functionX having * one set of dependencies and functionY having another set of dependencies. If you only add functionX, functionY * will also be included in the created jar since it is in the same package. However, only functionX's dependencies * will be traced and added to the jar, so you will run into issues when the platform tries to register functionY. * In this scenario, you must be certain to include specify both functionX and functionY when calling this method. * * @param artifactId the id of the artifact to add * @param parentArtifacts the parent artifacts it extends * @param pluginClass the plugin class to build the jar from * @param pluginClasses any additional plugin classes that should be included in the jar * @return an {@link ArtifactManager} to manage the added plugin artifact */ protected static ArtifactManager addPluginArtifact(ArtifactId artifactId, Set<ArtifactRange> parentArtifacts, Class<?> pluginClass, Class<?>... pluginClasses) throws Exception { return getTestManager().addPluginArtifact(artifactId, parentArtifacts, pluginClass, pluginClasses); }
/** * Build an artifact from the specified plugin classes and then add it. The * jar created will include all classes in the same package as the give classes, plus any dependencies of the * given classes. If another plugin in the same package as the given plugin requires a different set of dependent * classes, you must include both plugins. For example, suppose you have two plugins, * com.company.myapp.functions.functionX and com.company.myapp.function.functionY, with functionX having * one set of dependencies and functionY having another set of dependencies. If you only add functionX, functionY * will also be included in the created jar since it is in the same package. However, only functionX's dependencies * will be traced and added to the jar, so you will run into issues when the platform tries to register functionY. * In this scenario, you must be certain to include specify both functionX and functionY when calling this method. * * @param artifactId the id of the artifact to add * @param parent the parent artifact it extends * @param pluginClass the plugin class to build the jar from * @param pluginClasses any additional plugin classes that should be included in the jar * @return {@link ArtifactManager} to manage the added plugin artifact */ protected static ArtifactManager addPluginArtifact(ArtifactId artifactId, ArtifactId parent, Class<?> pluginClass, Class<?>... pluginClasses) throws Exception { return getTestManager().addPluginArtifact(artifactId, parent, pluginClass, pluginClasses); }