Run any SimpleBuild Step

src/main/java/com/groupon/jenkins/extensions/DotCiExtensionsHelper.java

@@ -24,7 +24,7 @@
 
 package com.groupon.jenkins.extensions;
 
-import com.google.common.collect.Iterables;
+import com.google.common.collect.*;
 import com.groupon.jenkins.buildtype.InvalidBuildConfigurationException;
 import com.groupon.jenkins.buildtype.plugins.DotCiPluginAdapter;
 import com.groupon.jenkins.notifications.PostBuildNotifier;
@@ -34,12 +34,16 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+
+import hudson.model.*;
+import hudson.tasks.*;
 import jenkins.model.Jenkins;
+import jenkins.tasks.*;
 
 public class DotCiExtensionsHelper {
     private Jenkins jenkins;
 
-     DotCiExtensionsHelper(Jenkins jenkins) {
+    DotCiExtensionsHelper(Jenkins jenkins) {
         this.jenkins = jenkins;
     }
     public DotCiExtensionsHelper() {
@@ -74,6 +78,8 @@ private <T extends DotCiExtension> List<T> createPlugins(List<?> pluginSpecs, Cl
         }
         return plugins;
     }
+
+
     public <T extends DotCiExtension>  T create(String pluginName, Object options, Class<T> extensionClass) {
         for (T adapter : all(extensionClass)) {
             if (adapter.getName().equals(pluginName)) {
@@ -87,9 +93,33 @@ public <T extends DotCiExtension>  T create(String pluginName, Object options, C
             }
 
         }
+
+        for(Descriptor<?> pluginDescriptor : getDescriptors()){
+            if(pluginDescriptor.clazz.getSimpleName().equals(pluginName)){
+                return (T) new GenericSimpleBuildStepPlugin(pluginDescriptor,options);
+            }
+        }
         throw new InvalidBuildConfigurationException("Plugin " + pluginName + " not supported");
     }
 
+    private ArrayList<Descriptor<?>> getDescriptors() {
+        ArrayList<Descriptor<?>> r = new ArrayList<Descriptor<?>>();
+        r.addAll( getClassList(Builder.class));
+        r. addAll( getClassList(Publisher.class));
+        return r;
+    }
+    private <T extends Describable<T>,D extends Descriptor<T>> List<Descriptor<?>> getClassList( Class<T> c) {
+        ArrayList<Descriptor<?>> r = new ArrayList<Descriptor<?>>();
+        if (jenkins == null) {
+            return new ArrayList<Descriptor<?>>();
+        }
+        for (Descriptor<?> d : jenkins.getDescriptorList(c)) {
+            if (SimpleBuildStep.class.isAssignableFrom(d.clazz)) {
+                r.add(d);
+            }
+        }
+        return r;
+    }
     public <T extends ExtensionPoint> Iterable<T> all(Class<T> extensionClass) {
         return jenkins.getExtensionList(extensionClass);
     }

src/main/java/com/groupon/jenkins/extensions/GenericSimpleBuildStepPlugin.java

@@ -0,0 +1,56 @@
+package com.groupon.jenkins.extensions;
+
+import com.groupon.jenkins.buildtype.plugins.*;
+import com.groupon.jenkins.dynamic.build.*;
+import hudson.*;
+import hudson.model.*;
+import hudson.tasks.*;
+import jenkins.tasks.*;
+import org.apache.commons.beanutils.*;
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+
+public class GenericSimpleBuildStepPlugin extends DotCiPluginAdapter {
+    private Descriptor<?> pluginDescriptor;
+    private Object options;
+
+    public GenericSimpleBuildStepPlugin(Descriptor<?> pluginDescriptor, Object options) {
+        super("");
+        this.pluginDescriptor = pluginDescriptor;
+        this.options = options;
+    }
+
+
+    @Override
+    public boolean perform(DynamicBuild dynamicBuild, Launcher launcher, BuildListener listener) {
+        SimpleBuildStep plugin = getPlugin();
+        try {
+            plugin.perform(dynamicBuild,launcher,listener);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        return false;
+    }
+    private SimpleBuildStep getPlugin(){
+
+        try {
+            SimpleBuildStep plugin = (SimpleBuildStep) pluginDescriptor.clazz.newInstance();
+            Map<String,Object> pluginOptions = (Map<String, Object>) options;
+           for(String method: pluginOptions.keySet()) {
+               BeanUtils.setProperty(plugin,method,pluginOptions.get(method));
+           }
+            return plugin;
+        } catch (InstantiationException e) {
+            throw new RuntimeException(e);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        } catch (InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}

src/test/java/com/groupon/jenkins/extensions/DotCiExtensionsHelperTest.java

@@ -24,25 +24,30 @@
 
 package com.groupon.jenkins.extensions;
 
+import com.google.common.collect.*;
 import com.groupon.jenkins.buildtype.plugins.DotCiPluginAdapter;
 import com.groupon.jenkins.dynamic.build.DynamicBuild;
-import hudson.ExtensionList;
-import hudson.Launcher;
-import hudson.model.BuildListener;
-import java.util.Arrays;
-import java.util.List;
+import hudson.*;
+import hudson.model.*;
+
+import java.io.*;
+import java.util.*;
+
+import hudson.tasks.*;
 import jenkins.model.Jenkins;
+import jenkins.tasks.*;
 import org.junit.Assert;
 import org.junit.Test;
 
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockingDetails;
 import static org.mockito.Mockito.when;
 
 public class DotCiExtensionsHelperTest {
 
     @Test
-    public void should_create_plugins(){
+    public void should_create_plugins_from_dotci_extensions(){
         Jenkins jenkins = mock(Jenkins.class);
         DotCiPluginAdapter plugin1 = getPlugin();
         ExtensionList extensionList = mock(ExtensionList.class);
@@ -53,6 +58,27 @@ public void should_create_plugins(){
         Assert.assertNotNull(plugins);
         Assert.assertEquals(plugin1.getName(),plugins.get(0).getName());
 
+    }
+    @Test
+    public void should_create_plugins_from_build_step_plugins(){
+        Jenkins jenkins = mock(Jenkins.class);
+
+        ExtensionList extensionList = mock(ExtensionList.class);
+        when(extensionList.iterator()).thenReturn(Lists.newArrayList().iterator());
+        when(jenkins.getExtensionList(any(Class.class))).thenReturn(extensionList);
+
+
+        DescriptorExtensionList<Builder, Descriptor<Builder>> descriptors =  mock(DescriptorExtensionList.class);
+        when(jenkins.getDescriptorList(any(Class.class))).thenReturn(descriptors);
+        Descriptor<Builder> buildStepDescriptor = new FakeBuildStepPlugin.FakeDescriptor();
+        when(descriptors.iterator()).thenReturn(Lists.newArrayList(buildStepDescriptor).iterator());
+
+        List<DotCiPluginAdapter> plugins = new DotCiExtensionsHelper(jenkins).createPlugins(Arrays.asList("FakeBuildStepPlugin"));
+
+        Assert.assertNotNull(plugins);
+        Assert.assertTrue(plugins.get(0) instanceof GenericSimpleBuildStepPlugin);
+
+
     }
 
     private DotCiPluginAdapter getPlugin() {
@@ -63,13 +89,28 @@ private static class FakePlugin extends DotCiPluginAdapter{
         public FakePlugin(){
             super("plugin1",null);
         }
-
-
         @Override
         public boolean perform(DynamicBuild dynamicBuild, Launcher launcher, BuildListener listener) {
             return false;
         }
     }
 
 
-}
+    private static  class FakeBuildStepPlugin extends Builder implements  SimpleBuildStep{
+        @Override
+        public void perform(Run<?, ?> run, FilePath workspace, Launcher launcher, TaskListener listener) throws InterruptedException, IOException {
+
+        }
+
+
+        private static class FakeDescriptor extends  Descriptor{
+
+            @Override
+            public String getDisplayName() {
+                return null;
+            }
+        }
+
+    }
+
+}