jenkins-plugin-runtime 0.1.6 → 0.1.7

data/spec/jenkins/launcher_spec.rb

@@ -1,8 +1,218 @@
 require 'spec_helper'
 
 describe Jenkins::Launcher do
+  before :each do
+    @native = mock("native")
+    @starter = mock("starter")
+    @cmd_proc = mock("proc")
+    @native.stub(:launch).and_return(@starter)
+    @starter.stub(:start).and_return(@cmd_proc)
+    @launcher = Jenkins::Launcher.new(@native)
+  end
 
   it "can be instantiated" do
     Jenkins::Launcher.new
   end
+
+  describe "execute" do
+    it "passes a simple command to a native launcher" do
+      @starter.should_receive(:envs).with({})
+      @starter.should_receive(:cmdAsSingleString).with("ls")
+      @cmd_proc.should_receive(:join).and_return(0)
+      @launcher.execute("ls").should == 0
+    end
+
+    describe "environment argument" do
+      it "passes env to a native launcher" do
+        @starter.should_receive(:envs).with({"foo" => "bar"})
+        @starter.should_receive(:cmdAsSingleString).with("ls")
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute({"foo" => "bar"}, "ls").should == 0
+      end
+
+      it "stringifies env for a native launcher" do
+        @starter.should_receive(:envs).with({"foo" => "bar", "baz" => "1"})
+        @starter.should_receive(:cmdAsSingleString).with("ls")
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute({:foo => :bar, :baz => 1}, "ls").should == 0
+      end
+    end
+
+    describe "option argument" do
+      it "passes pwd to a native launcher" do
+        @starter.should_receive(:envs).with({})
+        @starter.should_receive(:pwd).with(".")
+        @starter.should_receive(:cmdAsSingleString).with("ls")
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute("ls", :chdir => ".").should == 0
+      end
+
+      it "passes an output stream to a native launcher" do
+        ous = mock("OutputStream")
+        ous.should_receive(:to_outputstream).and_return(ous)
+        @starter.should_receive(:envs).with({})
+        @starter.should_receive(:stdout).with(ous)
+        @starter.should_receive(:cmdAsSingleString).with("ls")
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute("ls", :out => ous).should == 0
+      end
+
+      it "passes native listener as an output stream to a native launcher" do
+        ous = Jenkins::Model::Listener.new
+        plugin = mock("Plugin")
+        Jenkins::Plugin.should_receive(:instance).and_return(plugin)
+        plugin.should_receive(:export).with(ous).and_return(ous)
+
+        @starter.should_receive(:envs).with({})
+        @starter.should_receive(:stdout).with(ous)
+        @starter.should_receive(:cmdAsSingleString).with("ls")
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute("ls", :out => ous).should == 0
+      end
+
+      it "passes an input stream to a native launcher" do
+        ins = mock("InputStream")
+        ins.should_receive(:to_inputstream).and_return(ins)
+        @starter.should_receive(:envs).with({})
+        @starter.should_receive(:stdin).with(ins)
+        @starter.should_receive(:cmdAsSingleString).with("ls")
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute("ls", :in => ins).should == 0
+      end
+
+      it "passes an error stream to a native launcher" do
+        ous = mock("InputStream")
+        ous.should_receive(:to_outputstream).and_return(ous)
+        @starter.should_receive(:envs).with({})
+        @starter.should_receive(:stderr).with(ous)
+        @starter.should_receive(:cmdAsSingleString).with("ls")
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute("ls", :err => ous).should == 0
+      end
+    end
+
+    describe "command argument" do
+      it "passes a command to a native launcher" do
+        @starter.should_receive(:envs).with({})
+        @starter.should_receive(:cmdAsSingleString).with("echo foo bar")
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute("echo foo bar").should == 0
+      end
+
+      it "passes a stringified command to a native launcher" do
+        @starter.should_receive(:envs).with({})
+        @starter.should_receive(:cmdAsSingleString).with("ls")
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute(:ls).should == 0
+      end
+
+      it "passes a command as Array to a native launcher" do
+        @starter.should_receive(:envs).with({})
+        @starter.should_receive(:cmds).with(["echo", "foo", "bar"])
+        @cmd_proc.should_receive(:join).and_return(0)
+        @launcher.execute("echo", "foo", "bar").should == 0
+      end
+    end
+
+    describe "argument processing" do
+      it "passes env, a command and options to a native launcher" do
+        ins = mock("InputStream")
+        ins.should_receive(:to_inputstream).and_return(ins)
+        ous = mock("OutputStream")
+        ous.should_receive(:to_outputstream).and_return(ous)
+        errs = mock("ErrorOutputStream")
+        errs.should_receive(:to_outputstream).and_return(errs)
+        @starter.should_receive(:envs).with({"FOO" => "BAR"})
+        @starter.should_receive(:cmds).with(["echo", "hello", "world"])
+        @starter.should_receive(:stdin).with(ins)
+        @starter.should_receive(:stdout).with(ous)
+        @starter.should_receive(:stderr).with(errs)
+
+        @cmd_proc.should_receive(:join).and_return(1)
+        @launcher.execute({"FOO" => "BAR"}, "echo", "hello", "world", :in => ins, :out => ous, :err => errs).should == 1
+      end
+
+      it "converts env with to_hash for passing through" do
+        env = mock("hashy")
+        env.should_receive(:to_hash).and_return(:FOO => :BAR)
+        @starter.should_receive(:envs).with({"FOO" => "BAR"})
+        @starter.should_receive(:cmds).with(["echo", "hello", "world"])
+        @cmd_proc.should_receive(:join).and_return(1)
+        @launcher.execute(env, "echo", "hello", "world").should == 1
+      end
+
+      it "converts options with to_hash for processing" do
+        ous = mock("OutputStream")
+        ous.should_receive(:to_outputstream).and_return(ous)
+        env = mock("hashy env")
+        env.should_receive(:to_hash).and_return(:FOO => :BAR)
+        opt = mock("hashy opt")
+        opt.should_receive(:to_hash).and_return(:chdir => ".", :out => ous)
+        @starter.should_receive(:envs).with({"FOO" => "BAR"})
+        @starter.should_receive(:cmds).with(["echo", "hello", "world"])
+        @starter.should_receive(:pwd).with(".")
+        @starter.should_receive(:stdout).with(ous)
+        @cmd_proc.should_receive(:join).and_return(1)
+        @launcher.execute(env, "echo", "hello", "world", opt).should == 1
+      end
+    end
+  end
+
+  describe "spawn" do
+    it "works like execute without waiting for command execution" do
+      ous = mock("OutputStream")
+      ous.should_receive(:to_outputstream).and_return(ous)
+      env = mock("hashy env")
+      env.should_receive(:to_hash).and_return(:FOO => :BAR)
+      opt = mock("hashy opt")
+      opt.should_receive(:to_hash).and_return(:chdir => ".", :out => ous)
+      @starter.should_receive(:envs).with({"FOO" => "BAR"})
+      @starter.should_receive(:cmds).with(["echo", "hello", "world"])
+      @starter.should_receive(:pwd).with(".")
+      @starter.should_receive(:stdout).with(ous)
+      @cmd_proc.should_receive(:join).and_return(2)
+      @launcher.spawn(env, "echo", "hello", "world", opt).join.should == 2
+    end
+  end
+
+  describe Jenkins::Launcher::Proc do
+
+    subject { Jenkins::Launcher::Proc.new(@cmd_proc) }
+
+    it "passes an alive? call to a native proc" do
+      @cmd_proc.should_receive(:isAlive).and_return(true)
+      subject.alive?.should == true
+    end
+
+    it "passes a join call to a native proc" do
+      @cmd_proc.should_receive(:join).and_return(0)
+      subject.join.should == 0
+    end
+
+    it "passes a kill call to a native proc" do
+      @cmd_proc.should_receive(:kill).and_return(:guard)
+      subject.kill.should be_nil
+    end
+
+    it "passes a stdin call to a native proc" do
+      ins = mock("InputStream")
+      ins.should_receive(:to_io).and_return(ins)
+      @cmd_proc.should_receive(:getStdin).and_return(ins)
+      subject.stdin.should == ins
+    end
+
+    it "passes a stdout call to a native proc" do
+      ous = mock("OutputStream")
+      ous.should_receive(:to_io).and_return(ous)
+      @cmd_proc.should_receive(:getStdout).and_return(ous)
+      subject.stdout.should == ous
+    end
+
+    it "passes a stderr call to a native proc" do
+      errs = mock("OutputStream")
+      errs.should_receive(:to_io).and_return(errs)
+      @cmd_proc.should_receive(:getStderr).and_return(errs)
+      subject.stderr.should == errs
+    end
+  end
 end

data/spec/jenkins/model/action_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'jenkins/model/action'
+
 describe Jenkins::Model::Action do
 
   it "has the same display_name semantics as Model" do
@@ -35,8 +35,7 @@ describe Jenkins::Model::Action do
   private
 
   def new_action(&body)
-    action = Class.new
-    action.send(:include, Jenkins::Model::Action)
+    action = Class.new(Jenkins::Model::Action)
     action.class_eval(&body) if block_given?
     return action
   end

data/spec/jenkins/model/build_spec.rb

@@ -2,10 +2,29 @@ require 'spec_helper'
 
 describe Jenkins::Model::Build do
 
+  before :each do
+    @native = mock("AbstractBuild")
+    @subject = Jenkins::Model::Build.new(@native)
+  end
+
   it "can be instantiated" do
-    Jenkins::Model::Build.new(mock(Java.hudson.model.AbstractBuild))
+    Jenkins::Model::Build.new
+  end
+
+  it "returns workspace path" do
+    fs = Jenkins::FilePath.new(nil)
+    fs.should_receive(:getRemote).and_return(".")
+    @native.should_receive(:getWorkspace).and_return(fs)
+    @subject.workspace.to_s.should == "."
   end
 
-  # TODO: spec for build_var and env
-  # Just a mocking and method invocation checks are enough?
+  it "returns build variables as Hash-like" do
+    @native.should_receive(:getBuildVariables).and_return("FOO" => "BAR")
+    @subject.build_var.should == {"FOO" => "BAR"}
+  end
+
+  it "returns environment variables as Hash-like" do
+    @native.should_receive(:getEnvironment).with(nil).and_return("FOO" => "BAR")
+    @subject.env.should == {"FOO" => "BAR"}
+  end
 end

data/spec/jenkins/model/listener_spec.rb

@@ -9,23 +9,25 @@ describe Jenkins::Model::Listener do
   end
 
   it "logs messages" do
-    @listener.log('Hi')
-    @output.toString.should eql "Hi"
+    @listener.info('Hi')
+    @output.toString.should eql "Hi\n"
   end
 
   it "logs errors" do
     @listener.error('Oh no!')
-    @output.toString.should match /^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!/
+    @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")
+  it "logs if only severe" do
+    @listener.level = Logger::INFO
+    @listener.debug "debug"
+    @listener.info "info"
+    @output.toString.should == "info\n"
   end
 end
 

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

@@ -13,6 +13,17 @@ describe Jenkins::Plugin::Proxies::Builder do
       @object.should_receive(:prebuild).with(@build, @listener)
       @builder.prebuild(@jBuild, @jListener)
     end
+
+    it "returns true whatever Ruby side impl returns" do
+      @object.should_receive(:prebuild).and_return(false)
+      @builder.prebuild(@jBuild, @jListener).should == true
+    end
+
+    it "returns false when Ruby side impl raise an Error" do
+      @object.should_receive(:prebuild).and_raise(NoMethodError)
+      @jListener.should_receive(:error)
+      @builder.prebuild(@jBuild, @jListener).should == false
+    end
   end
 
   describe "perform" do

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Jenkins::Plugin::Proxies::Publisher do
+  include ProxyHelper
+
+  before do
+    @object = mock(Jenkins::Tasks::Publisher)
+    @builder = Jenkins::Plugin::Proxies::Publisher.new(@plugin, @object)
+  end
+
+  describe "prebuild" do
+    it "calls through to its implementation" do
+      @object.should_receive(:prebuild).with(@build, @listener)
+      @builder.prebuild(@jBuild, @jListener)
+    end
+
+    it "returns true whatever Ruby side impl returns" do
+      @object.should_receive(:prebuild).and_return(false)
+      @builder.prebuild(@jBuild, @jListener).should == true
+    end
+
+    it "returns false when Ruby side impl raise an Error" do
+      @object.should_receive(:prebuild).and_raise(NoMethodError)
+      @jListener.should_receive(:error)
+      @builder.prebuild(@jBuild, @jListener).should == false
+    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/root_action_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Jenkins::Plugin::Proxies::RootAction do
+  include ProxyHelper
+
+  before do
+    @object = mock(Jenkins::Model::RootAction)
+    @root_action = Jenkins::Plugin::Proxies::RootAction.new(@plugin, @object)
+  end
+
+  describe "getDisplayName" do
+    it "calls through to its implementation" do
+      @object.should_receive(:display_name)
+      @root_action.getDisplayName
+    end
+  end
+
+  describe "getIconFileName" do
+    it "calls through to its implementation" do
+      @object.should_receive(:icon)
+      @root_action.getIconFileName
+    end
+  end
+
+  describe "getUrlName" do
+    it "calls through to its implementation" do
+      @object.should_receive(:url_path)
+      @root_action.getUrlName
+    end
+  end
+end

data/spec/jenkins/plugin/proxies_spec.rb

@@ -41,7 +41,7 @@ describe Jenkins::Plugin::Proxies do
       end
 
       describe "and there is not an appropriate proxy class registered for it" do
-        it "raises an exception on import" do
+        it "raises an exception on export" do
           expect {@proxies.export(@object)}.should raise_error
         end
       end
@@ -133,6 +133,22 @@ describe Jenkins::Plugin::Proxies do
 
   end
 
+  describe "importing an unmapped native java object" do
+    before do
+      @umappable = java.lang.Object.new
+      @import = @proxies.import(@umappable)
+    end
+    it "maps it do an opaque native java object structure" do
+      @import.native.should be @umappable
+    end
+    it "reuses the same opaque proxy on subsequent imports" do
+      @proxies.import(@umappable).should be @import
+    end
+    it "exports the object as the original java value" do
+      @proxies.export(@import).should be @umappable
+    end
+  end
+
   private
 
   def proxy_class

data/spec/jenkins/plugin_spec.rb

@@ -1,7 +1,72 @@
 require 'spec_helper'
+require 'tmpdir'
 
 describe Jenkins::Plugin do
   it "is unbelievable that I don't have a spec for this class" do
     Jenkins::Plugin.instance_method(:initialize).should_not be_nil
   end
+
+  describe "when plugin loads models" do
+    include SpecHelper
+
+    it "only loads *.rb file" do
+      mktmpdir do |dir|
+        # - foo.rb
+        # - bar/
+        #   - bar1.rb
+        #   - bar2.rb
+        #   - baz/
+        #     - baz1.rb
+        #     - baz2.rb
+        #   - qux.rb
+        # - quux.rb
+        create_file(File.join(dir, "foo.rb"), "$T << :foo")
+        Dir.mkdir(File.join(dir, "bar"))
+        create_file(File.join(dir, "bar", "bar1.rb"), "$T << :bar1")
+        create_file(File.join(dir, "bar", "bar2.rb"), "$T << :bar2")
+        Dir.mkdir(File.join(dir, "bar", "baz"))
+        create_file(File.join(dir, "bar", "baz", "baz1.rb"), "$T << :baz1")
+        create_file(File.join(dir, "bar", "baz", "baz2.rb"), "$T << :baz2")
+        create_file(File.join(dir, "bar", "qux.rb"), "$T << :qux")
+        create_file(File.join(dir, "quux.rb"), "$T << :quux")
+        file = mock(:name => 'java.io.File')
+        file.stub(:getPath).and_return(dir)
+        peer = mock(:name => 'org.jenkinsci.ruby.RubyPlugin')
+        peer.stub(:getModelsPath).and_return(file)
+        plugin = Jenkins::Plugin.new(peer)
+
+        $T = []
+        plugin.load_models
+        foo = $T.index(:foo)
+        bar1 = $T.index(:bar1)
+        bar2 = $T.index(:bar2)
+        baz1 = $T.index(:baz1)
+        baz2 = $T.index(:baz2)
+        qux = $T.index(:qux)
+        quux = $T.index(:quux)
+
+        bar1.should > foo
+        bar1.should > quux
+
+        bar2.should > foo
+        bar2.should > quux
+
+        baz1.should > foo
+        baz1.should > bar1
+        baz1.should > bar2
+        baz1.should > qux
+        baz1.should > quux
+
+        baz2.should > foo
+        baz2.should > bar1
+        baz2.should > bar2
+        baz2.should > qux
+        baz2.should > quux
+
+        qux.should > foo
+        qux.should > quux
+        [foo, bar1, bar2, baz1, baz2, qux, quux].should_not include(-1)
+      end
+    end
+  end
 end