jenkins-plugin-runtime 0.1.0

data/spec/jenkins/model/build_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Jenkins::Model::Build do
+
+  it "can be instantiated" do
+    Jenkins::Model::Build.new(mock(Java.hudson.model.AbstractBuild))
+  end
+end

data/spec/jenkins/model/describable_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'rspec-spies'
+describe Jenkins::Model::Describable do
+
+  before do
+    @plugin = mock(Jenkins::Plugin)
+    Jenkins::Plugin.stub(:instance).and_return(@plugin)
+  end
+
+  describe "when mixed into a class" do
+    before do
+      @class = Class.new
+      @class.send(:include, Jenkins::Model::Describable)
+      @plugin.stub(:register_describable)
+    end
+
+
+    it "can't be described as plain old object" do
+      lambda {@class.describe_as Object}.should raise_error(Jenkins::Model::Describable::DescribableError)
+    end
+
+    it "can't be described as plain old java object" do
+      lambda {@class.describe_as java.lang.Object.new}.should raise_error(Jenkins::Model::Describable::DescribableError)
+    end
+
+    it "must be described as a java.lang.Class" do
+      lambda {@class.describe_as java.lang.Object}.should_not raise_error
+    end
+
+    describe "a subclass of that class" do
+      before do
+        @class.describe_as java.lang.Object
+        @subclass = Class.new(@class)
+      end
+
+      it "is registered as an extension of the java type" do
+        @plugin.should have_received(:register_describable).with(@subclass, java.lang.Object.java_class)
+      end
+
+      describe ". a sub-subclass" do
+        before do
+          @subsubclass = Class.new(@subclass)
+        end
+
+        it "is also registered as an extension of the original java type" do
+          @plugin.should have_received(:register_describable).with(@subsubclass, java.lang.Object.java_class)
+        end
+      end
+    end
+  end
+end

data/spec/jenkins/model/listener_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Jenkins::Model::Listener do
+
+  before do
+    @output = java.io.ByteArrayOutputStream.new
+    @java = Java.hudson.util.StreamTaskListener.new(@output)
+    @listener = Jenkins::Model::Listener.new(@java)
+  end
+
+  it "logs messages" do
+    @listener.log('Hi')
+    @output.toString.should eql "Hi"
+  end
+
+  it "logs errors" do
+    @listener.error('Oh no!')
+    @output.toString.should match /^ERROR: Oh no!/
+  end
+
+  it "logs fatal errors" do
+    @listener.fatal('boom!')
+    @output.toString.should match /^FATAL: boom!/
+  end
+
+  it "logs hyperlinks" do
+    @java.should_receive(:hyperlink).with("/foo/bar", "click here")
+    @listener.hyperlink("/foo/bar", "click here")
+  end
+end
+

data/spec/jenkins/model_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Jenkins::Model do
+  Model = Jenkins::Model
+
+  it "has a display name which is settable via the class, and accessable via the class and instance" do
+    cls = new_model do
+      display_name "One-Off Class"
+    end
+    cls.display_name.should eql "One-Off Class"
+    cls.new.display_name.should eql "One-Off Class"
+  end
+
+  it "passes down display_name capabilities to subclasses" do
+    parent = new_model
+    child = Class.new(parent)
+    child.class_eval do
+      display_name "Child"
+    end
+    child.display_name.should eql "Child"
+  end
+
+  it "passes down display_name capabilities to submodules" do
+    submodule = Module.new
+    submodule.send(:include, Jenkins::Model)
+    cls = Class.new
+    cls.send(:include, submodule)
+    cls.display_name "SubAwesome"
+    cls.display_name.should eql "SubAwesome"
+    cls.new.display_name.should eql "SubAwesome"
+  end
+
+  it "has a default display name of the class name" do
+    cls = new_model do
+      def self.name
+        "AwesomeClass"
+      end
+    end
+    cls.display_name.should eql "AwesomeClass"
+  end
+
+  it "keeps a list of which of its properties are transient" do
+    cls = new_model do
+      transient :foo, :bar
+    end
+    cls.should be_transient(:foo)
+    cls.should be_transient(:bar)
+    cls.should_not be_transient(:baz)
+  end
+
+  it "includes parent classes's transient properties, but doesn't affect the parent property list" do
+    parent = new_model do
+      transient :foo
+    end
+    child = Class.new(parent)
+    child.class_eval do
+      transient :bar
+    end
+    parent.should_not be_transient(:bar)
+    child.should be_transient(:foo)
+    child.should be_transient(:bar)
+  end
+
+  describe "tracking descendants" do
+    before do
+      Model.clear
+    end
+
+    it "captures including classes" do
+      cls = Class.new
+      cls.send(:include, Model)
+      Model.should be_descendant cls
+    end
+
+    it "captures classes that extend including classes" do
+      cls = Class.new
+      cls.send(:include, Model)
+      Model.should be_descendant(Class.new(cls))
+    end
+
+    it "captures classes that include including modules" do
+      m1 = Module.new
+      m1.send(:include, Model)
+      m2 = Module.new
+      m2.send(:include, m1)
+      cls = Class.new
+      cls.send(:include, m2)
+      Model.should be_descendant(Class.new(cls))
+    end
+  end
+
+  private
+
+  def new_model(&block)
+    cls = Class.new
+    cls.send(:include, Jenkins::Model)
+    cls.class_eval(&block) if block_given?
+    return cls
+  end
+end

data/spec/jenkins/plugin/proxies/build_wrapper_spec.rb

@@ -0,0 +1,25 @@
+
+require 'spec_helper'
+
+describe Jenkins::Plugin::Proxies::BuildWrapper do
+  include ProxyHelper
+
+  subject {Jenkins::Plugin::Proxies::BuildWrapper}
+  it {should be_transient(:plugin)}
+
+  before do
+    @object = mock(Jenkins::Tasks::BuildWrapper)
+    @wrapper = Jenkins::Plugin::Proxies::BuildWrapper.new(@plugin, @object)
+  end
+
+  it "passes in an env file which will be called to " do
+    env = nil
+    @object.should_receive(:setup).with(@build, @launcher, @listener, an_instance_of(Hash)) do |*args|
+      env = args.last
+    end
+    environment = @wrapper.setUp(@jBuild, @jLauncher, @jListener)
+
+    @object.should_receive(:teardown).with(@build, @listener, env)
+    environment.tearDown(@jBuild, @jListener)
+  end
+end

data/spec/jenkins/plugin/proxies/builder_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Jenkins::Plugin::Proxies::Builder do
+  include ProxyHelper
+
+  before do
+    @object = mock(Jenkins::Tasks::Builder)
+    @builder = Jenkins::Plugin::Proxies::Builder.new(@plugin, @object)
+  end
+
+  describe "prebuild" do
+    it "calls through to its implementation" do
+      @object.should_receive(:prebuild).with(@build, @launcher, @listener)
+      @builder.prebuild(@jBuild, @jLauncher, @jListener)
+    end
+  end
+
+  describe "perform" do
+    it "calls through to its implementation" do
+      @object.should_receive(:perform).with(@build, @launcher, @listener)
+      @builder.perform(@jBuild, @jLauncher, @jListener)
+    end
+  end
+end

data/spec/jenkins/plugin/proxies/proxy_helper.rb

@@ -0,0 +1,24 @@
+
+module ProxyHelper
+
+  def self.included(mod)
+    super
+    mod.class_eval do
+      before do
+        @plugin = mock(Jenkins::Plugin, :name => "test-plugin")
+
+        @jBuild = mock(Java.hudson.model.AbstractBuild)
+        @jLauncher = mock(Java.hudson.Launcher)
+        @jListener = mock(Java.hudson.model.BuildListener)
+
+        @build = mock(Jenkins::Model::Build)
+        @launcher = mock(Jenkins::Launcher)
+        @listener = mock(Jenkins::Model::Listener)
+
+        @plugin.stub(:import).with(@jBuild).and_return(@build)
+        @plugin.stub(:import).with(@jLauncher).and_return(@launcher)
+        @plugin.stub(:import).with(@jListener).and_return(@listener)
+      end
+    end
+  end
+end

data/spec/jenkins/plugin/proxies_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Jenkins::Plugin::Proxies do
+  Proxies = Jenkins::Plugin::Proxies
+  before  do
+    Proxies.clear
+    @plugin = mock(Jenkins::Plugin)
+    @proxies = Jenkins::Plugin::Proxies.new(@plugin)
+  end
+
+  describe "exporting a native ruby object" do
+
+    before do
+      @class = Class.new
+      @object = @class.new
+    end
+
+    describe "when no wrapper exists for it" do
+
+      describe "and there is a matching proxy class registered" do
+        before do
+          @proxy_class = Class.new
+          @proxy_class.class_eval do
+            attr_reader :plugin, :object
+            def initialize(plugin, object)
+              @plugin, @object = plugin, object
+            end
+          end
+          Jenkins::Plugin::Proxies.register @class, @proxy_class
+          @export = @proxies.export(@object)
+        end
+
+        it "instantiates the proxy" do
+          @export.should be_kind_of(@proxy_class)
+        end
+
+        it "passes in the plugin and the wrapped object" do
+          @export.plugin.should be(@plugin)
+          @export.object.should be(@object)
+        end
+      end
+
+      describe "and there is not an appropriate proxy class registered for it" do
+        it "raises an exception on import" do
+          expect {@proxies.export(@object)}.should raise_error
+        end
+      end
+    end
+
+    describe "when a wrapper has already existed" do
+      before do
+        @proxy = Object.new
+        @proxies.link @object, @proxy
+      end
+
+      it "finds the same proxy on export" do
+        @proxies.export(@object).should be(@proxy)
+      end
+
+      it "finds associated Ruby object on import" do
+        @proxies.import(@proxy).should be(@object)
+      end
+    end
+
+    describe "proxy matching" do
+      describe "when there are two related classes" do
+        before do
+          @A = Class.new
+          @B = Class.new(@A)
+          @A.class_eval do
+            attr_reader :native
+            def initialize(native = nil)
+              @native = native
+            end
+          end
+        end
+
+        describe "and there is a proxy registered for the subclass but not the superclass" do
+          before do
+            @p = proxy_class
+            Proxies.register @B, @p
+          end
+
+          it "will create a proxy for the subclass" do
+            @proxies.export(@B.new).should be_kind_of(@p)
+          end
+
+          it "will create a native for the external class" do
+            internal = @proxies.import(@p.new)
+            internal.should be_kind_of(@B)
+          end
+
+          it "will fail to create a proxy for the superclass" do
+            expect {@proxies.export @A.new}.should raise_error(Jenkins::Plugin::ExportError)
+          end
+        end
+
+        describe "and there is a proxy registered for the superclass but not the superclass" do
+          before do
+            @p = proxy_class
+            Proxies.register @A, @p
+          end
+          it "will create a proxy for the superclass" do
+            @proxies.export(@A.new).should be_kind_of(@p)
+            @proxies.import(@p.new).should be_kind_of(@A)
+          end
+
+          it "will create a proxy for the subclass" do
+            @proxies.export(@B.new).should be_kind_of(@p)
+          end
+        end
+
+        describe "and there is proxy registered for both classes" do
+
+          before do
+            @pA = proxy_class
+            @pB = proxy_class
+            Proxies.register @A, @pA
+            Proxies.register @B, @pB
+          end
+          it "will create a proxy for the subclass with its registered proxy class" do
+            @proxies.export(@A.new).should be_kind_of(@pA)
+            @proxies.import(@pA.new).should be_kind_of(@A)
+          end
+
+          it "will create a proxy for the superclass with its registered proxy class" do
+            @proxies.export(@B.new).should be_kind_of(@pB)
+            @proxies.import(@pB.new).should be_kind_of(@B)
+          end
+        end
+      end
+    end
+
+  end
+
+  private
+
+  def proxy_class
+    cls = Class.new
+    cls.class_eval do
+      attr_reader :plugin, :object
+      def initialize(plugin = nil, object = nil)
+        @plugin, @object = plugin, object
+      end
+    end
+    return cls
+  end
+end

data/spec/jenkins/plugin/proxy_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe "a class with #{Jenkins::Plugin::Proxy} mixed in" do
+
+  before do
+    @class = Class.new
+    @class.send(:include, Jenkins::Plugin::Proxy)
+  end
+
+  it "treats the plugin as transient" do
+    @class.transient?(:plugin).should be_true
+  end
+
+  it "leaves other fields alone" do
+    @class.transient?(:object).should be_false
+  end
+
+  describe "unmarshalling" do
+    before do
+      @class.class_eval do
+        attr_reader :plugin
+      end
+      @plugin = mock(Jenkins::Plugin)
+      @impl = impl = Object.new
+      @proxy = @class.allocate
+      @proxy.instance_eval do
+        @pluginid = "test-plugin"
+        @object = impl
+      end
+      @jenkins = mock(Java.jenkins.model.Jenkins)
+      @java_plugin = mock(:RubyPlugin, :getNativeRubyPlugin => @plugin)
+      @jenkins.stub(:getPlugin).with("test-plugin").and_return(@java_plugin)
+      Java.jenkins.model.Jenkins.stub(:getInstance).and_return(@jenkins)
+    end
+
+    it "reconstructs the @plugin field" do
+      @plugin.should_receive(:link).with(@impl, @proxy)
+      @proxy.read_completed
+      @proxy.plugin.should be(@plugin)
+    end
+  end
+
+end