mcollective-client 1.3.3

data/spec/unit/rpc/actionrunner_spec.rb

@@ -0,0 +1,213 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module RPC
+    describe ActionRunner do
+      before(:each) do
+        @req = mock
+        @req.stubs(:agent).returns("spectester")
+        @req.stubs(:action).returns("tester")
+
+        command = "/bin/echo 1"
+
+        @runner = ActionRunner.new(command, @req, :json)
+      end
+
+      describe "#initialize" do
+        it "should set command" do
+          @runner.command.should == "/bin/echo 1"
+        end
+
+        it "should set agent" do
+          @runner.agent.should == "spectester"
+        end
+
+        it "should set action" do
+          @runner.action.should == "tester"
+        end
+
+        it "should set format" do
+          @runner.format.should == :json
+        end
+
+        it "should set request" do
+          @runner.request.should == @req
+        end
+
+        it "should set stdout" do
+          @runner.stdout.should == ""
+        end
+
+        it "should set stderr" do
+          @runner.stderr.should == ""
+        end
+
+        it "should set the command via path_to_command" do
+          ActionRunner.any_instance.expects(:path_to_command).with("rspec").once
+          ActionRunner.new("rspec", @req, :json)
+        end
+      end
+
+      describe "#shell" do
+        it "should create a shell instance with correct settings" do
+          s = @runner.shell("test", "infile", "outfile")
+
+          s.command.should == "test infile outfile"
+          s.cwd.should == Dir.tmpdir
+          s.stdout.should == ""
+          s.stderr.should == ""
+          s.environment["MCOLLECTIVE_REQUEST_FILE"].should == "infile"
+          s.environment["MCOLLECTIVE_REPLY_FILE"].should == "outfile"
+        end
+      end
+
+      describe "#load_results" do
+        it "should call the correct format loader" do
+          req = mock
+          req.expects(:agent).returns("spectester")
+          req.expects(:action).returns("tester")
+
+          runner = ActionRunner.new("/bin/echo 1", req, :foo)
+          runner.expects("load_foo_results").returns({:foo => :bar})
+          runner.load_results("/dev/null").should == {:foo => :bar}
+        end
+
+        it "should set all keys to Symbol" do
+          data = {"foo" => "bar", "bar" => "baz"}
+          Tempfile.open("mcollective_test", Dir.tmpdir) do |f|
+            f.puts data.to_json
+            f.close
+
+            results = @runner.load_results(f.path)
+            results.should == {:foo => "bar", :bar => "baz"}
+          end
+        end
+      end
+
+      describe "#load_json_results" do
+        it "should load data from a file" do
+          Tempfile.open("mcollective_test", Dir.tmpdir) do |f|
+            f.puts '{"foo":"bar","bar":"baz"}'
+            f.close
+
+            @runner.load_json_results(f.path).should == {"foo" => "bar", "bar" => "baz"}
+          end
+
+        end
+
+        it "should return empty data on JSON parse error" do
+          @runner.load_json_results("/dev/null").should == {}
+        end
+
+        it "should return empty data for missing files" do
+          @runner.load_json_results("/nonexisting").should == {}
+        end
+
+        it "should load complex data correctly" do
+          data = {"foo" => "bar", "bar" => {"one" => "two"}}
+          Tempfile.open("mcollective_test", Dir.tmpdir) do |f|
+            f.puts data.to_json
+            f.close
+
+            @runner.load_json_results(f.path).should == data
+          end
+        end
+
+      end
+
+      describe "#saverequest" do
+        it "should call the correct format serializer" do
+          req = mock
+          req.expects(:agent).returns("spectester")
+          req.expects(:action).returns("tester")
+
+          runner = ActionRunner.new("/bin/echo 1", req, :foo)
+
+          runner.expects("save_foo_request").with(req).returns('{"foo":"bar"}')
+
+          runner.saverequest(req)
+        end
+
+        it "should save to a temp file" do
+          @req.expects(:to_json).returns({:foo => "bar"}.to_json)
+          fname = @runner.saverequest(@req).path
+
+          JSON.load(File.read(fname)).should == {"foo" => "bar"}
+          File.dirname(fname).should == Dir.tmpdir
+        end
+      end
+
+      describe "#save_json_request" do
+        it "should return correct json data" do
+          @req.expects(:to_json).returns({:foo => "bar"}.to_json)
+          @runner.save_json_request(@req).should == '{"foo":"bar"}'
+        end
+      end
+
+      describe "#canrun?" do
+        it "should correctly report executables" do
+          if Util.windows?
+            @runner.canrun?(File.join(ENV['SystemRoot'], "explorer.exe")).should == true
+          else
+            @runner.canrun?("/bin/true").should == true
+          end
+        end
+
+        it "should detect missing files" do
+          @runner.canrun?("/nonexisting").should == false
+        end
+      end
+
+      describe "#to_s" do
+        it "should return correct data" do
+          @runner.to_s.should == "spectester#tester command: /bin/echo 1"
+        end
+      end
+
+      describe "#tempfile" do
+        it "should return a TempFile" do
+          @runner.tempfile("foo").class.should == Tempfile
+        end
+
+        it "should contain the prefix in its name" do
+          @runner.tempfile("foo").path.should match(/foo/)
+        end
+      end
+
+      describe "#path_to_command" do
+        it "should return the command if it starts with separator" do
+          command = "#{File::SEPARATOR}rspec"
+
+          runner = ActionRunner.new(command , @req, :json)
+          runner.path_to_command(command).should == command
+        end
+
+        it "should find the first match in the libdir" do
+          Config.any_instance.expects(:libdir).returns(["#{File::SEPARATOR}libdir1", "#{File::SEPARATOR}libdir2"])
+
+          action_in_first_dir = File.join(File::SEPARATOR, "libdir1", "agent", "spectester", "action.sh")
+          action_in_last_dir = File.join(File::SEPARATOR, "libdir2", "agent", "spectester", "action.sh")
+
+          File.expects("exist?").with(action_in_first_dir).returns(true)
+          File.expects("exist?").with(action_in_last_dir).never
+
+          ActionRunner.new("action.sh", @req, :json).command.should == action_in_first_dir
+        end
+
+        it "should find the match even in the last libdir" do
+          Config.any_instance.expects(:libdir).returns(["#{File::SEPARATOR}libdir1", "#{File::SEPARATOR}libdir2"])
+
+          action_in_first_dir = File.join(File::SEPARATOR, "libdir1", "agent", "spectester", "action.sh")
+          action_in_last_dir = File.join(File::SEPARATOR, "libdir2", "agent", "spectester", "action.sh")
+
+          File.expects("exist?").with(action_in_first_dir).returns(false)
+          File.expects("exist?").with(action_in_last_dir).returns(true)
+
+          ActionRunner.new("action.sh", @req, :json).command.should == action_in_last_dir
+        end
+      end
+    end
+  end
+end

data/spec/unit/rpc/agent_spec.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module RPC
+    describe Agent do
+      before do
+        @agent = Agent.new
+        @agent.reply = {}
+        @agent.request = {}
+      end
+
+      describe "#run" do
+        before do
+          @status = mock
+          @status.stubs(:exitstatus).returns(0)
+          @shell = mock
+          @shell.stubs(:runcommand)
+          @shell.stubs(:status).returns(@status)
+        end
+
+        it "should accept stderr and stdout and force them to be strings" do
+          Shell.expects(:new).with("rspec", {:stderr => "", :stdout => ""}).returns(@shell)
+          @agent.send(:run, "rspec", {:stderr => :err, :stdout => :out})
+          @agent.reply[:err].should == ""
+          @agent.reply[:out].should == ""
+        end
+
+        it "should accept existing variables for stdout and stderr and fail if they dont support <<" do
+          @agent.reply[:err] = "err"
+          @agent.reply[:out] = "out"
+
+          Shell.expects(:new).with("rspec", {:stderr => "err", :stdout => "out"}).returns(@shell)
+          @agent.send(:run, "rspec", {:stderr => @agent.reply[:err], :stdout => @agent.reply[:out]})
+          @agent.reply[:err].should == "err"
+          @agent.reply[:out].should == "out"
+
+          @agent.reply.expects("fail!").with("stderr should support << while calling run(rspec)").raises("stderr fail")
+          expect { @agent.send(:run, "rspec", {:stderr => nil, :stdout => ""}) }.to raise_error("stderr fail")
+
+          @agent.reply.expects("fail!").with("stdout should support << while calling run(rspec)").raises("stdout fail")
+          expect { @agent.send(:run, "rspec", {:stderr => "", :stdout => nil}) }.to raise_error("stdout fail")
+        end
+
+        it "should set stdin, cwd and environment if supplied" do
+          Shell.expects(:new).with("rspec", {:stdin => "stdin", :cwd => "cwd", :environment => "env"}).returns(@shell)
+          @agent.send(:run, "rspec", {:stdin => "stdin", :cwd => "cwd", :environment => "env"})
+        end
+
+        it "should ignore unknown options" do
+          Shell.expects(:new).with("rspec", {}).returns(@shell)
+          @agent.send(:run, "rspec", {:rspec => "rspec"})
+        end
+
+        it "should chomp strings if configured to do so" do
+          Shell.expects(:new).with("rspec", {:stderr => 'err', :stdout => 'out'}).returns(@shell)
+
+          @agent.reply[:err] = "err"
+          @agent.reply[:out] = "out"
+
+          @agent.reply[:err].expects("chomp!")
+          @agent.reply[:out].expects("chomp!")
+
+          @agent.send(:run, "rspec", {:chomp => true, :stdout => @agent.reply[:out], :stderr => @agent.reply[:err]})
+        end
+
+        it "should return the exitstatus" do
+          Shell.expects(:new).with("rspec", {}).returns(@shell)
+          @agent.send(:run, "rspec", {}).should == 0
+        end
+
+        it "should handle nil from the shell handler" do
+          @shell.expects(:status).returns(nil)
+          Shell.expects(:new).with("rspec", {}).returns(@shell)
+          @agent.send(:run, "rspec", {}).should == -1
+        end
+      end
+
+      describe "#validate" do
+        it "should detect missing data" do
+          @agent.request = {}
+          expect { @agent.send(:validate, :foo, String) }.to raise_error(MissingRPCData, "please supply a foo argument")
+        end
+
+        it "should support regular expressions" do
+          @agent.request = {:foo => "this is a test, 123"}
+
+          expect { @agent.send(:validate, :foo, /foo/) }.to raise_error(InvalidRPCData, /foo should match/)
+          @agent.send(:validate, :foo, /is a test, \d\d\d$/)
+        end
+
+        it "should support type checking" do
+          @agent.request = {:str => "foo"}
+
+          expect { @agent.send(:validate, :str, Numeric) }.to raise_error(InvalidRPCData, /str should be a Numeric/)
+          @agent.send(:validate, :str, String)
+        end
+
+        it "should correctly validate ipv4 addresses" do
+          @agent.request = {:goodip4 => "1.1.1.1",
+                            :badip4  => "300.300.300.300"}
+
+          expect { @agent.send(:validate, :badip4, :ipv4address) }.to raise_error(InvalidRPCData, /badip4 should be an ipv4 address/)
+          @agent.send(:validate, :goodip4, :ipv4address)
+        end
+
+        it "should correctly validate ipv6 addresses" do
+          @agent.request = {:goodip6 => "2a00:1450:8006::93",
+                            :badip6  => "300.300.300.300"}
+
+          expect { @agent.send(:validate, :badip6, :ipv6address) }.to raise_error(InvalidRPCData, /badip6 should be an ipv6 address/)
+          @agent.send(:validate, :goodip6, :ipv6address)
+        end
+
+        it "should correctly validate boolean data" do
+          @agent.request = {:true => true, :false => false, :string => "foo", :number => 1}
+
+          @agent.send(:validate, :true, :boolean)
+          @agent.send(:validate, :false, :boolean)
+          expect { @agent.send(:validate, :string, :boolean) }.to raise_error(InvalidRPCData)
+          expect { @agent.send(:validate, :number, :boolean) }.to raise_error(InvalidRPCData)
+        end
+
+        it "should correctly validate list data" do
+          @agent.request = {:str => "foo"}
+          expect { @agent.send(:validate, :str, ["bar", "baz"]) }.to raise_error(InvalidRPCData, /str should be one of bar, baz/)
+
+          @agent.request = {:str => "foo"}
+          expect { @agent.send(:validate, :str, ["bar", "baz", "foo"]) }
+          @agent.send(:validate, :str, ["bar", "baz", "foo"])
+        end
+
+        it "should correctly identify characters that are not shell safe" do
+          @agent.request = {:backtick => 'foo`bar',
+                            :semicolon => 'foo;bar',
+                            :dollar => 'foo$(bar)',
+                            :pipe => 'foo|bar',
+                            :redirto => 'foo>bar',
+                            :inputfrom => 'foo<bar',
+                            :good => 'foo bar baz'}
+
+          expect { @agent.send(:validate, :backtick, :shellsafe) }.to raise_error(InvalidRPCData, /backtick should not have ` in it/)
+          expect { @agent.send(:validate, :semicolon, :shellsafe) }.to raise_error(InvalidRPCData, /semicolon should not have ; in it/)
+          expect { @agent.send(:validate, :dollar, :shellsafe) }.to raise_error(InvalidRPCData, /dollar should not have \$ in it/)
+          expect { @agent.send(:validate, :pipe, :shellsafe) }.to raise_error(InvalidRPCData, /pipe should not have \| in it/)
+          expect { @agent.send(:validate, :redirto, :shellsafe) }.to raise_error(InvalidRPCData, /redirto should not have > in it/)
+          expect { @agent.send(:validate, :inputfrom, :shellsafe) }.to raise_error(InvalidRPCData, /inputfrom should not have \< in it/)
+
+          @agent.send(:validate, :good, :shellsafe)
+        end
+      end
+    end
+  end
+end

data/spec/unit/rpc/client_spec.rb

@@ -0,0 +1,523 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module RPC
+    describe Client do
+      describe "#limit_method" do
+        before do
+          client = stub
+
+          client.stubs("options=")
+          client.stubs(:collective).returns("mcollective")
+
+          Config.any_instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+          MCollective::Client.expects(:new).returns(client)
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+
+          @client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+        end
+
+        it "should force strings to symbols" do
+          @client.limit_method = "first"
+          @client.limit_method.should == :first
+        end
+
+        it "should only allow valid methods" do
+          @client.limit_method = :first
+          @client.limit_method.should == :first
+          @client.limit_method = :random
+          @client.limit_method.should == :random
+
+          expect { @client.limit_method = :fail }.to raise_error(/Unknown/)
+          expect { @client.limit_method = "fail" }.to raise_error(/Unknown/)
+        end
+      end
+
+      describe "#method_missing" do
+        before do
+          client = stub
+          client.stubs("options=")
+          client.stubs(:collective).returns("mcollective")
+          MCollective::Client.stubs(:new).returns(client)
+
+          Config.any_instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+        end
+
+        it "should reset the stats" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.stubs(:call_agent)
+
+          Stats.any_instance.expects(:reset).once
+          client.foo
+        end
+
+        it "should validate the request against the ddl" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+
+          client.stubs(:call_agent)
+
+          ddl = mock
+          ddl.expects(:validate_request).with("rspec", {:arg => :val}).raises("validation failed")
+          client.instance_variable_set("@ddl", ddl)
+
+          expect { client.rspec(:arg => :val) }.to raise_error("validation failed")
+        end
+
+        it "should support limited targets" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.limit_targets = 10
+
+          client.expects(:pick_nodes_from_discovered).with(10).returns(["one", "two"])
+          client.expects(:custom_request).with("foo", {}, ["one", "two"], {"identity" => /^(one|two)$/}).once
+
+          client.foo
+        end
+
+        describe "batch mode" do
+          before do
+            Config.any_instance.stubs(:direct_addressing).returns(true)
+            @client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          end
+
+          it "should support global batch_size" do
+            @client.batch_size = 10
+            @client.expects(:call_agent_batched).with("rspec", {}, @client.options, 10, 1)
+            @client.rspec
+          end
+
+          it "should support custom batch_size" do
+            @client.expects(:call_agent_batched).with("rspec", {}, @client.options, 10, 1)
+            @client.rspec :batch_size => 10
+          end
+
+          it "should allow supplied batch_size override global one" do
+            @client.batch_size = 10
+            @client.expects(:call_agent_batched).with("rspec", {}, @client.options, 20, 1)
+            @client.rspec :batch_size => 20
+          end
+
+          it "should support global batch_sleep_time" do
+            @client.batch_size = 10
+            @client.batch_sleep_time = 20
+            @client.expects(:call_agent_batched).with("rspec", {}, @client.options, 10, 20)
+            @client.rspec
+          end
+
+          it "should support custom batch_sleep_time" do
+            @client.batch_size = 10
+            @client.expects(:call_agent_batched).with("rspec", {}, @client.options, 10, 20)
+            @client.rspec :batch_sleep_time => 20
+          end
+
+          it "should allow supplied batch_sleep_time override global one" do
+            @client.batch_size = 10
+            @client.batch_sleep_time = 10
+            @client.expects(:call_agent_batched).with("rspec", {}, @client.options, 10, 20)
+            @client.rspec :batch_sleep_time => 20
+          end
+        end
+
+        it "should support normal calls" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+
+          client.expects(:call_agent).with("foo", {}, client.options, :auto).once
+
+          client.foo
+        end
+      end
+
+      describe "#limit_targets=" do
+        before do
+          client = stub
+
+          client.stubs("options=")
+          client.stubs(:collective).returns("mcollective")
+
+          Config.any_instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+          MCollective::Client.expects(:new).returns(client)
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+
+          @client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+        end
+
+        it "should support percentages" do
+          @client.limit_targets = "10%"
+          @client.limit_targets.should == "10%"
+        end
+
+        it "should support integers" do
+          @client.limit_targets = 10
+          @client.limit_targets.should == 10
+          @client.limit_targets = "20"
+          @client.limit_targets.should == 20
+          @client.limit_targets = 1.1
+          @client.limit_targets.should == 1
+          @client.limit_targets = 1.7
+          @client.limit_targets.should == 1
+        end
+
+        it "should not invalid limits to be set" do
+          expect { @client.limit_targets = "a" }.to raise_error /Invalid/
+          expect { @client.limit_targets = "%1" }.to raise_error /Invalid/
+          expect { @client.limit_targets = "1.1" }.to raise_error /Invalid/
+        end
+      end
+
+      describe "#call_agent_batched" do
+        before do
+          @client = stub
+
+          @client.stubs("options=")
+          @client.stubs(:collective).returns("mcollective")
+
+          Config.any_instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+          MCollective::Client.expects(:new).returns(@client)
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+        end
+
+        it "should require direct addressing" do
+          Config.any_instance.stubs(:direct_addressing).returns(false)
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+
+          expect {
+            client.send(:call_agent_batched, "foo", {}, {}, 1, 1)
+          }.to raise_error("Batched requests requires direct addressing")
+        end
+
+        it "should require that all results be processed" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+
+          expect {
+            client.send(:call_agent_batched, "foo", {:process_results => false}, {}, 1, 1)
+          }.to raise_error("Cannot bypass result processing for batched requests")
+        end
+
+        it "should only accept integer batch sizes" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+
+          expect {
+            client.send(:call_agent_batched, "foo", {}, {}, "foo", 1)
+          }.to raise_error(/invalid value for Integer/)
+        end
+
+        it "should only accept float sleep times" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+
+          expect {
+            client.send(:call_agent_batched, "foo", {}, {}, 1, "foo")
+          }.to raise_error(/invalid value for Float/)
+        end
+
+        it "should batch hosts in the correct size" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :stderr => StringIO.new}})
+
+          client.expects(:new_request).returns("req")
+
+          discovered = mock
+          discovered.stubs(:size).returns(1)
+          discovered.expects(:in_groups_of).with(10).raises("spec pass")
+          @client.stubs(:discover).returns(discovered)
+
+          expect { client.send(:call_agent_batched, "foo", {}, {}, 10, 1) }.to raise_error("spec pass")
+        end
+
+        it "should force direct requests" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :stderr => StringIO.new}})
+
+          Message.expects(:new).with('req', nil, {:type => :direct_request, :agent => 'foo', :filter => nil, :options => {}, :collective => 'mcollective'}).raises("spec pass")
+          client.expects(:new_request).returns("req")
+
+          @client.stubs(:discover).returns(["test"])
+
+          expect { client.send(:call_agent_batched, "foo", {}, {}, 1, 1) }.to raise_error("spec pass")
+        end
+
+        it "should process blocks correctly" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :stderr => StringIO.new}})
+
+          msg = mock
+          msg.expects(:discovered_hosts=).times(10)
+
+          stats = {:noresponsefrom => [], :responses => 0, :blocktime => 0, :totaltime => 0, :discoverytime => 0}
+
+          Message.expects(:new).with('req', nil, {:type => :direct_request, :agent => 'foo', :filter => nil, :options => {}, :collective => 'mcollective'}).returns(msg).times(10)
+          client.expects(:new_request).returns("req")
+          client.expects(:sleep).with(1.0).times(9)
+
+          @client.stubs(:discover).returns([1,2,3,4,5,6,7,8,9,0])
+          @client.expects(:req).with(msg).yields("result").times(10)
+          @client.stubs(:stats).returns stats
+
+          client.expects(:process_results_with_block).with("foo", "result", instance_of(Proc)).times(10)
+
+          result = client.send(:call_agent_batched, "foo", {}, {}, 1, 1) { }
+          result.class.should == Stats
+        end
+
+        it "should return an array of results in array mode" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :stderr => StringIO.new}})
+
+          msg = mock
+          msg.expects(:discovered_hosts=).times(10)
+
+          stats = {:noresponsefrom => [], :responses => 0, :blocktime => 0, :totaltime => 0, :discoverytime => 0}
+
+          Progress.expects(:new).never
+
+          Message.expects(:new).with('req', nil, {:type => :direct_request, :agent => 'foo', :filter => nil, :options => {}, :collective => 'mcollective'}).returns(msg).times(10)
+          client.expects(:new_request).returns("req")
+          client.expects(:sleep).with(1.0).times(9)
+
+          @client.stubs(:discover).returns([1,2,3,4,5,6,7,8,9,0])
+          @client.expects(:req).with(msg).yields("result").times(10)
+          @client.stubs(:stats).returns stats
+
+          client.expects(:process_results_without_block).with("result", "foo").returns("rspec").times(10)
+
+          client.send(:call_agent_batched, "foo", {}, {}, 1, 1).should == ["rspec", "rspec", "rspec", "rspec", "rspec", "rspec", "rspec", "rspec", "rspec", "rspec"]
+        end
+      end
+
+      describe "#batch_sleep_time=" do
+        before do
+          @client = stub
+
+          @client.stubs("options=")
+          @client.stubs(:collective).returns("mcollective")
+
+          Config.any_instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+          MCollective::Client.expects(:new).returns(@client)
+        end
+
+        it "should correctly set the sleep" do
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.batch_sleep_time = 5
+          client.batch_sleep_time.should == 5
+        end
+
+        it "should only allow batch sleep to be set for direct addressing capable clients" do
+          Config.any_instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+
+          expect { client.batch_sleep_time = 5 }.to raise_error("Can only set batch sleep time if direct addressing is supported")
+        end
+      end
+
+      describe "#batch_size=" do
+        before do
+          @client = stub
+
+          @client.stubs("options=")
+          @client.stubs(:collective).returns("mcollective")
+
+          Config.any_instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+          MCollective::Client.expects(:new).returns(@client)
+        end
+
+        it "should correctly set the size" do
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.batch_mode.should == false
+          client.batch_size = 5
+          client.batch_size.should == 5
+          client.batch_mode.should == true
+        end
+
+        it "should only allow batch size to be set for direct addressing capable clients" do
+          Config.any_instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+
+          expect { client.batch_size = 5 }.to raise_error("Can only set batch size if direct addressing is supported")
+        end
+
+        it "should support disabling batch mode when supplied a batch size of 0" do
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.batch_size = 5
+          client.batch_mode.should == true
+          client.batch_size = 0
+          client.batch_mode.should == false
+        end
+      end
+
+      describe "#discover" do
+        before do
+          @client = stub
+
+          @client.stubs("options=")
+          @client.stubs(:collective).returns("mcollective")
+
+          @stderr = stub
+          @stdout = stub
+
+          Config.any_instance.stubs(:loadconfig).with("/nonexisting").returns(true)
+          MCollective::Client.expects(:new).returns(@client)
+        end
+
+        it "should not accept invalid flags" do
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+
+          expect { client.discover(:rspec => :rspec) }.to raise_error("Unknown option rspec passed to discover")
+        end
+
+        it "should reset when :json, :hosts or :nodes are provided" do
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.expects(:reset).times(3)
+          client.discover(:hosts => ["one"])
+          client.discover(:nodes => ["one"])
+          client.discover(:json => ["one"])
+        end
+
+        it "should only allow discovery data in direct addressing mode" do
+          Config.any_instance.stubs(:direct_addressing).returns(false)
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.expects(:reset).once
+
+          expect {
+            client.discover(:nodes => ["one"])
+          }.to raise_error("Can only supply discovery data if direct_addressing is enabled")
+        end
+
+        it "should parse :nodes and :hosts and force direct requests" do
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+          Helpers.expects(:extract_hosts_from_array).with(["one"]).returns(["one"]).twice
+
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.discover(:nodes => ["one"]).should == ["one"]
+          client.discover(:hosts => ["one"]).should == ["one"]
+          client.instance_variable_get("@force_direct_request").should == true
+          client.instance_variable_get("@discovered_agents").should == ["one"]
+        end
+
+        it "should parse :json and force direct requests" do
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+          Helpers.expects(:extract_hosts_from_json).with('["one"]').returns(["one"]).once
+
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.discover(:json => '["one"]').should == ["one"]
+          client.instance_variable_get("@force_direct_request").should == true
+          client.instance_variable_get("@discovered_agents").should == ["one"]
+        end
+
+        it "should force direct mode for non regex identity filters" do
+          Config.any_instance.stubs(:direct_addressing).returns(true)
+
+          client = Client.new("foo", {:options => {:filter => {"identity" => ["foo"], "agent" => []}, :config => "/nonexisting"}})
+          client.discover
+          client.instance_variable_get("@discovered_agents").should == ["foo"]
+          client.instance_variable_get("@force_direct_request").should == true
+        end
+
+        it "should not set direct mode if its disabled" do
+          Config.any_instance.stubs(:direct_addressing).returns(false)
+
+          client = Client.new("foo", {:options => {:filter => {"identity" => ["foo"], "agent" => []}, :config => "/nonexisting"}})
+
+          client.discover
+          client.instance_variable_get("@force_direct_request").should == false
+          client.instance_variable_get("@discovered_agents").should == ["foo"]
+        end
+
+        it "should not set direct mode for regex identities" do
+          Config.any_instance.stubs(:direct_addressing).returns(false)
+
+          @client.expects(:discover).with({'identity' => ['/foo/'], 'agent' => ['foo']}, nil).once.returns(["foo"])
+          client = Client.new("foo", {:options => {:filter => {"identity" => ["/foo/"], "agent" => []}, :config => "/nonexisting"}})
+
+          client.discover
+          client.instance_variable_get("@force_direct_request").should == false
+          client.instance_variable_get("@discovered_agents").should == ["foo"]
+        end
+
+        it "should print status to stderr if in verbose mode" do
+          @client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          @stderr.expects(:print).with("Determining the amount of hosts matching filter for 2 seconds .... ")
+          @stderr.expects(:puts).with(1)
+
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => true, :disctimeout => 2, :stderr => @stderr, :stdout => @stdout}})
+          client.discover
+        end
+
+        it "should not print status to stderr if in verbose mode" do
+          @client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2, :stderr => @stderr, :stdout => @stdout}})
+
+          @stderr.expects(:print).never
+          @stderr.expects(:puts).never
+
+          client.discover
+        end
+
+        it "should record the start and end times" do
+          Stats.any_instance.expects(:time_discovery).with(:start)
+          Stats.any_instance.expects(:time_discovery).with(:end)
+
+          @client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
+
+          client.discover
+        end
+
+        it "should discover using limits in :first rpclimit mode given a number" do
+          Config.any_instance.stubs(:rpclimitmethod).returns(:first)
+          @client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2, 1).returns(["foo"])
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
+          client.limit_targets = 1
+
+          client.discover
+        end
+
+        it "should not discover using limits in :first rpclimit mode given a string" do
+          Config.any_instance.stubs(:rpclimitmethod).returns(:first)
+          @client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
+          client.limit_targets = "10%"
+
+          client.discover
+        end
+
+        it "should not discover using limits when not in :first mode" do
+          Config.any_instance.stubs(:rpclimitmethod).returns(:random)
+          @client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
+          client.limit_targets = 1
+
+          client.discover
+        end
+
+        it "should ensure force_direct mode is false when doing traditional discovery" do
+          @client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
+
+          client.instance_variable_set("@force_direct_request", true)
+          client.discover
+          client.instance_variable_get("@force_direct_request").should == false
+        end
+
+        it "should store discovered nodes in stats" do
+          @client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
+
+          client.discover
+          client.stats.discovered_nodes.should == ["foo"]
+        end
+
+        it "should save discovered nodes in RPC" do
+          @client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
+
+          RPC.expects(:discovered).with(["foo"]).once
+          client.discover
+        end
+      end
+    end
+  end
+end