mcollective-client 2.6.1 → 2.7.0

data/spec/unit/message_spec.rb

@@ -300,6 +300,36 @@ module MCollective
           m.decode!
         }.to raise_error('callerid in request is not valid, surpressing reply to potentially forged request')
       end
+
+      it 'should handle the securityprovider failing to decodemsg - log for reply' do
+        security = mock('securityprovider')
+        security.expects(:decodemsg).raises('squirrel attack')
+
+        PluginManager.expects("[]").with("security_plugin").returns(security).once
+
+        m = Message.new("payload", "message", :type => :reply)
+        m.stubs(:headers).returns({'mc_sender' => 'trees'})
+        Log.expects(:warn).with("Failed to decode a message from 'trees': squirrel attack")
+
+        expect {
+          m.decode!
+        }.to_not raise_error
+      end
+
+      it 'should handle the securityprovider failing to decodemsg' do
+        security = mock('securityprovider')
+        security.expects(:decodemsg).raises('squirrel attack')
+
+        PluginManager.expects("[]").with("security_plugin").returns(security).once
+
+        m = Message.new("payload", "message", :type => :request)
+        Log.expects(:warn).never
+
+        expect {
+          m.decode!
+        }.to raise_error(/squirrel attack/)
+      end
+
     end
 
     describe "#validate_compound_filter" do

data/spec/unit/optionparser_spec.rb

@@ -197,6 +197,12 @@ module MCollective
         @parser.instance_variable_get(:@options)[:discovery_options].should == ['nodes.txt']
       end
 
+      it 'should parse the --nodes option' do
+        ARGV << '--connection-timeout=1'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:connection_timeout].should == 1
+      end
+
       it 'should fail on the --nodes option if discovery_method or discovery_options have already been set' do
       end
 

data/spec/unit/pluginpackager/agent_definition_spec.rb

@@ -87,6 +87,7 @@ module MCollective
       describe "#agent" do
         before do
           AgentDefinition.any_instance.expects(:client).once
+          PluginPackager.expects(:get_plugin_path).with(".").returns(".")
         end
 
         it "should not populate the agent files if the agent directory is empty" do
@@ -101,14 +102,27 @@ module MCollective
           PluginPackager.stubs(:check_dir_present).returns(true)
           File.stubs(:join).with(".", "agent").returns("tmpdir/agent")
           File.stubs(:join).with("tmpdir/agent", "*.ddl").returns("tmpdir/agent/*.ddl")
-          File.stubs(:join).with("tmpdir/agent", "*").returns("tmpdir/agent/*")
+          File.stubs(:join).with("tmpdir/agent", "**", "**").returns("tmpdir/agent/**/**")
           Dir.stubs(:glob).with("tmpdir/agent/*.ddl").returns([])
-          Dir.stubs(:glob).with("tmpdir/agent/*").returns(["implementation.rb"])
+          Dir.stubs(:glob).with("tmpdir/agent/**/**").returns(["implementation.rb"])
 
           agent = AgentDefinition.new(configuration, {}, "agent")
           agent.packagedata[:agent][:files].should == ["implementation.rb"]
         end
 
+        it "should recursively populate the file list if the agent directory contains subdirectories" do
+          AgentDefinition.any_instance.expects(:common).returns(nil)
+          PluginPackager.stubs(:check_dir_present).returns(true)
+          File.stubs(:join).with(".", "agent").returns("tmpdir/agent")
+          File.stubs(:join).with("tmpdir/agent", "*.ddl").returns("tmpdir/agent/*.ddl")
+          File.stubs(:join).with("tmpdir/agent", "**", "**").returns("tmpdir/agent/**/**")
+          Dir.stubs(:glob).with("tmpdir/agent/*.ddl").returns([])
+          Dir.stubs(:glob).with("tmpdir/agent/**/**").returns(["implementation.rb", "test/test.rb"])
+
+          agent = AgentDefinition.new(configuration, {}, "agent")
+          agent.packagedata[:agent][:files].should == ["implementation.rb", "test/test.rb"]
+        end
+
         it "should add common package as dependency if present" do
           AgentDefinition.any_instance.expects(:common).returns({:files=> ["test.rb"]})
           PluginPackager.expects(:check_dir_present).with("tmpdir/agent").returns(true)
@@ -125,6 +139,10 @@ module MCollective
       end
 
       describe "#common" do
+        before :each do
+          PluginPackager.expects(:get_plugin_path).with(".").returns(".")
+        end
+
         it "should populate the common files if there are any" do
           AgentDefinition.any_instance.expects(:agent)
           AgentDefinition.any_instance.expects(:client)
@@ -163,6 +181,7 @@ module MCollective
           AgentDefinition.any_instance.expects(:agent).returns(nil)
           File.expects(:join).with(".", "application").returns("clientdir")
           File.expects(:join).with(".", "aggregate").returns("aggregatedir")
+          PluginPackager.expects(:get_plugin_path).with(".").returns(".")
         end
 
         it "should populate client files if all directories are present" do

data/spec/unit/pluginpackager/standard_definition_spec.rb

@@ -73,6 +73,9 @@ module MCollective
       end
 
       describe "#plugin" do
+        before :each do
+          PluginPackager.expects(:get_plugin_path).with(".").returns(".")
+        end
 
         it "should return nil if the plugin doesn't contain any files" do
           StandardDefinition.any_instance.expects(:common).returns(nil)
@@ -102,8 +105,9 @@ module MCollective
       end
 
       describe "#common" do
-        before do
+        before :each do
           StandardDefinition.any_instance.expects(:plugin).returns(false)
+          PluginPackager.expects(:get_plugin_path).with(".").returns(".")
         end
 
         it "should return nil if common doesn't contain any files" do

data/spec/unit/plugins/mcollective/connector/activemq_spec.rb

@@ -110,7 +110,7 @@ module MCollective
           Activemq.any_instance.stubs(:get_bool_option).with("activemq.backup", "false").returns(true)
           Activemq.any_instance.stubs(:get_option).with("activemq.timeout", -1).returns(1)
           Activemq.any_instance.stubs(:get_option).with("activemq.connect_timeout", 30).returns(5)
-          Activemq.any_instance.stubs(:get_option).with("activemq.max_hbrlck_fails", 2).returns(2)
+          Activemq.any_instance.stubs(:get_option).with("activemq.max_hbrlck_fails", 0).returns(0)
           Activemq.any_instance.stubs(:get_option).with("activemq.max_hbread_fails", 2).returns(2)
           Activemq.any_instance.stubs(:get_bool_option).with("activemq.base64", 'false').returns(false)
           Activemq.any_instance.stubs(:get_option).with("activemq.priority", 0).returns(0)
@@ -150,8 +150,8 @@ module MCollective
                                        :use_exponential_back_off => true,
                                        :max_reconnect_attempts => 5,
                                        :initial_reconnect_delay => 0.01,
+                                       :max_hbrlck_fails => 0,
                                        :max_hbread_fails => 2,
-                                       :max_hbrlck_fails => 2,
                                        :randomize => true,
                                        :reliable => true,
                                        :logger => "logger",
@@ -651,6 +651,15 @@ module MCollective
           headers["timestamp"].should == "1368557431000"
           headers["expires"].should == "1368557541000"
         end
+
+        it "should set mc_sender based on the identity" do
+          message = mock
+          message.expects(:type).returns(:foo)
+          message.stubs(:ttl).returns(100)
+
+          headers = connector.headers_for(message)
+          headers['mc_sender'].should == 'rspec'
+        end
       end
 
       describe "#make_target" do

data/spec/unit/plugins/mcollective/connector/rabbitmq_spec.rb

@@ -111,7 +111,7 @@ module MCollective
           Rabbitmq.any_instance.stubs(:get_bool_option).with("rabbitmq.backup", "false").returns(true)
           Rabbitmq.any_instance.stubs(:get_option).with("rabbitmq.timeout", -1).returns(1)
           Rabbitmq.any_instance.stubs(:get_option).with("rabbitmq.connect_timeout", 30).returns(5)
-          Rabbitmq.any_instance.stubs(:get_option).with("rabbitmq.max_hbrlck_fails", 2).returns(2)
+          Rabbitmq.any_instance.stubs(:get_option).with("rabbitmq.max_hbrlck_fails", 0).returns(0)
           Rabbitmq.any_instance.stubs(:get_option).with("rabbitmq.max_hbread_fails", 2).returns(2)
           Rabbitmq.any_instance.stubs(:get_bool_option).with("rabbitmq.base64", 'false').returns(false)
           Rabbitmq.any_instance.stubs(:get_option).with("rabbitmq.pool.size").returns(2)
@@ -150,8 +150,8 @@ module MCollective
                                        :use_exponential_back_off => true,
                                        :max_reconnect_attempts => 5,
                                        :initial_reconnect_delay => 0.01,
+                                       :max_hbrlck_fails => 0,
                                        :max_hbread_fails => 2,
-                                       :max_hbrlck_fails => 2,
                                        :randomize => true,
                                        :reliable => true,
                                        :logger => "logger",
@@ -453,8 +453,18 @@ module MCollective
           msg.stubs(:ttl).returns(60)
           msg.expects(:discovered_hosts).returns(["one", "two"])
 
-          connection.expects(:publish).with('/exchange/mcollective_directed/one', 'msg', {'reply-to' => '/topic/mcollective', 'expiration' => '70000'})
-          connection.expects(:publish).with('/exchange/mcollective_directed/two', 'msg', {'reply-to' => '/topic/mcollective', 'expiration' => '70000'})
+          connection.expects(:publish).with('/exchange/mcollective_directed/one',
+                                            'msg',
+                                            { 'reply-to'    => '/topic/mcollective',
+                                              'expiration'  => '70000',
+                                              'mc_sender'   => 'rspec',
+                                            })
+          connection.expects(:publish).with('/exchange/mcollective_directed/two',
+                                            'msg',
+                                            { 'reply-to'    => '/topic/mcollective',
+                                              'expiration'  => '70000',
+                                              'mc_sender'   => 'rspec',
+                                            })
 
           connector.publish(msg)
         end
@@ -551,7 +561,14 @@ module MCollective
 
           message.expects(:request).returns(request)
 
-          connector.target_for(message).should == {:name => "foo", :headers => {"expiration" => "70000"}, :id => ""}
+          connector.target_for(message).should == {
+            :name => "foo",
+            :headers => {
+              "expiration" => "70000",
+              'mc_sender'  => 'rspec',
+            },
+            :id => "",
+          }
         end
 
         it "should create new request targets" do

data/spec/unit/plugins/mcollective/data/collective_data_spec.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+require File.dirname(__FILE__) + "/../../../../../plugins/mcollective/data/collective_data.rb"
+
+module MCollective
+  module Data
+    describe Collective_data do
+      describe "#query_data" do
+        before :each do
+          @ddl = mock('DDL')
+          @ddl.stubs(:dataquery_interface).returns({:output => {}})
+          @ddl.stubs(:meta).returns({:timeout => 1})
+          DDL.stubs(:new).returns(@ddl)
+          @plugin = Collective_data.new
+
+          Config.instance.stubs(:collectives).returns([ "collective_a", "collective_b" ])
+        end
+
+        it 'should return true if you are a member of the named collective' do
+          @plugin.query_data("collective_a")
+          @plugin.result[:member].should == true
+        end
+
+        it 'should return false if you are a member of the named collective' do
+          @plugin.query_data("no_such_collective")
+          @plugin.result[:member].should == false
+        end
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/packagers/modulepackage_packager_spec.rb

@@ -125,6 +125,11 @@ module MCollective
       describe '#make_module' do
         it 'should copy the package content to the tmp build dir' do
           file = mock()
+
+          ['./agent/rspec.rb', './agent/rspec.ddl', './application/rspec.rb'].each do |m|
+            File.stubs(:expand_path).with(m).returns(m)
+          end
+
           File.stubs(:directory?).with('rspec_tmp/manifests').returns(false, true)
           File.stubs(:directory?).with('rspec_tmp/files/agent/mcollective/agent').returns(false, true)
           File.stubs(:directory?).with('rspec_tmp/files/common/mcollective/agent').returns(false, true)

data/spec/unit/rpc/actionrunner_spec.rb

@@ -189,25 +189,54 @@ module MCollective
           Config.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_first_dir_new = File.join(File::SEPARATOR, "libdir1", "mcollective", "agent", "spectester", "action.sh")
           action_in_last_dir = File.join(File::SEPARATOR, "libdir2", "agent", "spectester", "action.sh")
+          action_in_last_dir_new = File.join(File::SEPARATOR, "libdir2", "mcollective", "agent", "spectester", "action.sh")
 
-          File.expects("exist?").with(action_in_first_dir).returns(true)
-          File.expects("exist?").with(action_in_last_dir).never
-
+          File.expects("exists?").with(action_in_first_dir).returns(true)
+          File.expects("exists?").with(action_in_first_dir_new).returns(false)
+          File.expects("exists?").with(action_in_last_dir).never
+          File.expects("exists?").with(action_in_last_dir_new).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
+        it "should find the match in the last libdir" do
           Config.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_first_dir_new = File.join(File::SEPARATOR, "libdir1", "mcollective", "agent", "spectester", "action.sh")
           action_in_last_dir = File.join(File::SEPARATOR, "libdir2", "agent", "spectester", "action.sh")
+          action_in_last_dir_new = File.join(File::SEPARATOR, "libdir2", "mcollective", "agent", "spectester", "action.sh")
 
-          File.expects("exist?").with(action_in_first_dir).returns(false)
-          File.expects("exist?").with(action_in_last_dir).returns(true)
-
+          File.expects("exists?").with(action_in_first_dir).returns(false)
+          File.expects("exists?").with(action_in_first_dir_new).returns(false)
+          File.expects("exists?").with(action_in_last_dir).returns(true)
+          File.expects("exists?").with(action_in_last_dir_new).returns(false)
           ActionRunner.new("action.sh", @req, :json).command.should == action_in_last_dir
         end
+
+        it "should find the match in the 'new' directory layout" do
+          Config.instance.expects(:libdir).returns(["#{File::SEPARATOR}libdir1", "#{File::SEPARATOR}libdir2"])
+
+          action_in_new_dir = File.join(File::SEPARATOR, "libdir1", "mcollective", "agent", "spectester", "action.sh")
+          action_in_old_dir = File.join(File::SEPARATOR, "libdir1", "agent", "spectester", "action.sh")
+
+          File.expects("exists?").with(action_in_new_dir).returns(true)
+          File.expects("exists?").with(action_in_old_dir).returns(false)
+          ActionRunner.new("action.sh", @req, :json).command.should == action_in_new_dir
+        end
+
+        it "if the script is both the old and new locations, the new location should be preferred" do
+          Config.instance.expects(:libdir).returns(["#{File::SEPARATOR}libdir1", "#{File::SEPARATOR}libdir2"])
+
+          action_in_new_dir = File.join(File::SEPARATOR, "libdir1", "mcollective", "agent", "spectester", "action.sh")
+          action_in_old_dir = File.join(File::SEPARATOR, "libdir1", "agent", "spectester", "action.sh")
+
+          File.expects("exists?").with(action_in_new_dir).returns(true)
+          File.expects("exists?").with(action_in_old_dir).returns(true)
+
+          ActionRunner.new("action.sh", @req, :json).command.should == action_in_new_dir
+        end
       end
     end
   end

data/spec/unit/rpc/client_spec.rb

@@ -923,7 +923,11 @@ module MCollective
 
           rpcclient = Client.new("foo", {:options => {:filter => {"identity" => ["/foo/"], "agent" => []}, :config => "/nonexisting"}})
 
-          rpcclient.client.expects(:discover).with({'identity' => ['/foo/'], 'agent' => ['foo']}, 2).once.returns(["foo"])
+          rpcclient.client.expects(:discover).with({
+            'identity' => ['/foo/'],
+            'agent' => ['foo'],
+            'collective' => 'mcollective',
+          }, 2).once.returns(["foo"])
 
           rpcclient.discover
           rpcclient.instance_variable_get("@force_direct_request").should == false
@@ -934,9 +938,25 @@ module MCollective
           @stderr.expects(:print).with("Discovering hosts using the mc method for 2 second(s) .... ")
           @stderr.expects(:puts).with(1)
 
-          rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => true, :disctimeout => 2, :stderr => @stderr, :stdout => @stdout}})
-
-          rpcclient.client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          rpcclient = Client.new("foo", {
+            :options => {
+              :filter => Util.empty_filter,
+              :config => "/nonexisting",
+              :verbose => true,
+              :disctimeout => 2,
+              :stderr => @stderr,
+              :stdout => @stdout,
+            },
+          })
+
+          rpcclient.client.expects(:discover).with({
+            'identity' => [],
+            'compound' => [],
+            'fact' => [],
+            'agent' => ['foo'],
+            'cf_class' => [],
+            'collective' => 'mcollective',
+          }, 2).returns(["foo"])
 
           rpcclient.discover
         end
@@ -945,8 +965,24 @@ module MCollective
           @stderr.expects(:print).never
           @stderr.expects(:puts).never
 
-          rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2, :stderr => @stderr, :stdout => @stdout}})
-          rpcclient.client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          rpcclient = Client.new("foo", {
+            :options => {
+              :filter => Util.empty_filter,
+              :config => "/nonexisting",
+              :verbose => false,
+              :disctimeout => 2,
+              :stderr => @stderr,
+              :stdout => @stdout,
+            },
+          })
+          rpcclient.client.expects(:discover).with({
+            'identity' => [],
+            'compound' => [],
+            'fact' => [],
+            'agent' => ['foo'],
+            'cf_class' => [],
+            'collective' => 'mcollective',
+          }, 2).returns(["foo"])
 
           rpcclient.discover
         end
@@ -955,16 +991,44 @@ module MCollective
           Stats.any_instance.expects(:time_discovery).with(:start)
           Stats.any_instance.expects(:time_discovery).with(:end)
 
-          rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
-          rpcclient.client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          rpcclient = Client.new("foo", {
+            :options => {
+              :filter => Util.empty_filter,
+              :config => "/nonexisting",
+              :verbose => false,
+              :disctimeout => 2,
+            },
+          })
+          rpcclient.client.expects(:discover).with({
+            'identity' => [],
+            'compound' => [],
+            'fact' => [],
+            'agent' => ['foo'],
+            'cf_class' => [],
+            'collective' => 'mcollective',
+          }, 2).returns(["foo"])
 
           rpcclient.discover
         end
 
         it "should discover using limits in :first rpclimit mode given a number" do
           Config.instance.stubs(:rpclimitmethod).returns(:first)
-          rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
-          rpcclient.client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2, 1).returns(["foo"])
+          rpcclient = Client.new("foo", {
+            :options => {
+              :filter => Util.empty_filter,
+              :config => "/nonexisting",
+              :verbose => false,
+              :disctimeout => 2,
+            },
+          })
+          rpcclient.client.expects(:discover).with({
+            'identity' => [],
+            'compound' => [],
+            'fact' => [],
+            'agent' => ['foo'],
+            'cf_class' => [],
+            'collective' => 'mcollective',
+          }, 2, 1).returns(["foo"])
 
           rpcclient.limit_targets = 1
 
@@ -973,8 +1037,22 @@ module MCollective
 
         it "should not discover using limits in :first rpclimit mode given a string" do
           Config.instance.stubs(:rpclimitmethod).returns(:first)
-          rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
-          rpcclient.client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          rpcclient = Client.new("foo", {
+            :options => {
+              :filter => Util.empty_filter,
+              :config => "/nonexisting",
+              :verbose => false,
+              :disctimeout => 2,
+            },
+          })
+          rpcclient.client.expects(:discover).with({
+            'identity' => [],
+            'compound' => [],
+            'fact' => [],
+            'agent' => ['foo'],
+            'cf_class' => [],
+            'collective' => 'mcollective',
+          }, 2).returns(["foo"])
           rpcclient.limit_targets = "10%"
 
           rpcclient.discover
@@ -983,16 +1061,44 @@ module MCollective
         it "should not discover using limits when not in :first mode" do
           Config.instance.stubs(:rpclimitmethod).returns(:random)
 
-          rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
-          rpcclient.client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          rpcclient = Client.new("foo", {
+            :options => {
+              :filter => Util.empty_filter,
+              :config => "/nonexisting",
+              :verbose => false,
+              :disctimeout => 2,
+            },
+          })
+          rpcclient.client.expects(:discover).with({
+            'identity' => [],
+            'compound' => [],
+            'fact' => [],
+            'agent' => ['foo'],
+            'cf_class' => [],
+            'collective' => 'mcollective',
+          }, 2).returns(["foo"])
 
           rpcclient.limit_targets = 1
           rpcclient.discover
         end
 
         it "should ensure force_direct mode is false when doing traditional discovery" do
-          rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
-          rpcclient.client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          rpcclient = Client.new("foo", {
+            :options => {
+              :filter => Util.empty_filter,
+              :config => "/nonexisting",
+              :verbose => false,
+              :disctimeout => 2,
+            },
+          })
+          rpcclient.client.expects(:discover).with({
+            'identity' => [],
+            'compound' => [],
+            'fact' => [],
+            'agent' => ['foo'],
+            'cf_class' => [],
+            'collective' => 'mcollective',
+          }, 2).returns(["foo"])
 
           rpcclient.instance_variable_set("@force_direct_request", true)
           rpcclient.discover
@@ -1000,16 +1106,44 @@ module MCollective
         end
 
         it "should store discovered nodes in stats" do
-          rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
-          rpcclient.client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          rpcclient = Client.new("foo", {
+            :options => {
+              :filter => Util.empty_filter,
+              :config => "/nonexisting",
+              :verbose => false,
+              :disctimeout => 2,
+            },
+          })
+          rpcclient.client.expects(:discover).with({
+            'identity' => [],
+            'compound' => [],
+            'fact' => [],
+            'agent' => ['foo'],
+            'cf_class' => [],
+            'collective' => 'mcollective',
+          }, 2).returns(["foo"])
 
           rpcclient.discover
           rpcclient.stats.discovered_nodes.should == ["foo"]
         end
 
         it "should save discovered nodes in RPC" do
-          rpcclient = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting", :verbose => false, :disctimeout => 2}})
-          rpcclient.client.expects(:discover).with({'identity' => [], 'compound' => [], 'fact' => [], 'agent' => ['foo'], 'cf_class' => []}, 2).returns(["foo"])
+          rpcclient = Client.new("foo", {
+            :options => {
+              :filter => Util.empty_filter,
+              :config => "/nonexisting",
+              :verbose => false,
+              :disctimeout => 2,
+            },
+          })
+          rpcclient.client.expects(:discover).with({
+            'identity' => [],
+            'compound' => [],
+            'fact' => [],
+            'agent' => ['foo'],
+            'cf_class' => [],
+            'collective' => 'mcollective',
+          }, 2).returns(["foo"])
 
           RPC.expects(:discovered).with(["foo"]).once
           rpcclient.discover
@@ -1018,31 +1152,31 @@ module MCollective
 
       describe "#determine_batch_mode" do
         let(:rpcclient) do
-          rpcclient = Client.new("foo", 
-                                 {:options => {:filter => Util.empty_filter, 
-                                               :config => "/nonexisting", 
-                                               :verbose => false, 
+          rpcclient = Client.new("foo",
+                                 {:options => {:filter => Util.empty_filter,
+                                               :config => "/nonexisting",
+                                               :verbose => false,
                                                :disctimeout => 2}})
         end
 
         it "should return true when batch_mode should be set" do
           rpcclient.send(:determine_batch_mode, "1").should == true
-          rpcclient.send(:determine_batch_mode, 1).should == true    
-          rpcclient.send(:determine_batch_mode, "1%").should == true    
+          rpcclient.send(:determine_batch_mode, 1).should == true
+          rpcclient.send(:determine_batch_mode, "1%").should == true
         end
 
         it "should return false when batch_mode shouldn't be set" do
           rpcclient.send(:determine_batch_mode, "0").should == false
-          rpcclient.send(:determine_batch_mode, 0).should == false   
+          rpcclient.send(:determine_batch_mode, 0).should == false
         end
       end
 
       describe "#validate_batch_size" do
         let(:rpcclient) do
-          rpcclient = Client.new("foo", 
-                                 {:options => {:filter => Util.empty_filter, 
-                                               :config => "/nonexisting", 
-                                               :verbose => false, 
+          rpcclient = Client.new("foo",
+                                 {:options => {:filter => Util.empty_filter,
+                                               :config => "/nonexisting",
+                                               :verbose => false,
                                                :disctimeout => 2}})
         end