mcollective-client 2.5.3 → 2.6.0

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

@@ -47,9 +47,9 @@ module MCollective
 
       let(:subscription) do
         sub = mock
-        sub.stubs("<<").returns(true)
-        sub.stubs("include?").returns(false)
-        sub.stubs("delete").returns(false)
+        sub.stubs(:<<).returns(true)
+        sub.stubs(:include?).returns(false)
+        sub.stubs(:delete).returns(false)
         sub
       end
 
@@ -432,8 +432,8 @@ 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' => '/temp-queue/mcollective_reply_agent', 'expiration' => '70000'})
-          connection.expects(:publish).with('/exchange/mcollective_directed/two', 'msg', {'reply-to' => '/temp-queue/mcollective_reply_agent', 'expiration' => '70000'})
+          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'})
 
           connector.publish(msg)
         end
@@ -447,12 +447,12 @@ module MCollective
         end
 
         it "should use the make_target correctly" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
           connector.subscribe("test", :broadcast, "mcollective")
         end
 
         it "should check for existing subscriptions" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
           subscription.expects("include?").with("rspec").returns(false)
           connection.expects(:subscribe).never
 
@@ -460,14 +460,14 @@ module MCollective
         end
 
         it "should subscribe to the middleware" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
           connection.expects(:subscribe).with("test", {}, "rspec")
           connector.subscribe("test", :broadcast, "mcollective")
         end
 
         it "should add to the list of subscriptions" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
-          subscription.expects("<<").with("rspec")
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          subscription.expects(:<<).with("rspec")
           connector.subscribe("test", :broadcast, "mcollective")
         end
 
@@ -478,7 +478,7 @@ module MCollective
 
         it "should subscribe to :reply messages when use_reply_exchange is set" do
           Rabbitmq.any_instance.stubs(:get_bool_option).with("rabbitmq.use_reply_exchange", false).returns(true)
-          connector.expects("make_target").with("test", :reply, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          connector.expects(:make_target).with("test", :reply, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
           connection.expects(:subscribe).with("test", {}, "rspec").once
 
           connector.subscribe("test", :reply, "mcollective")
@@ -487,19 +487,19 @@ module MCollective
 
       describe "#unsubscribe" do
         it "should use make_target correctly" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
           connector.unsubscribe("test", :broadcast, "mcollective")
         end
 
         it "should unsubscribe from the target" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
           connection.expects(:unsubscribe).with("test", {}, "rspec").once
 
           connector.unsubscribe("test", :broadcast, "mcollective")
         end
 
         it "should delete the source from subscriptions" do
-          connector.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          connector.expects(:make_target).with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
           subscription.expects(:delete).with("rspec").once
 
           connector.unsubscribe("test", :broadcast, "mcollective")
@@ -512,7 +512,7 @@ module MCollective
 
         it "should unsubscribe from :reply messages when use_reply_exchange is set" do
           Rabbitmq.any_instance.stubs(:get_bool_option).with("rabbitmq.use_reply_exchange", false).returns(true)
-          connector.expects("make_target").with("test", :reply, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          connector.expects(:make_target).with("test", :reply, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
           connection.expects(:unsubscribe).with("test", {}, "rspec").once
 
           connector.unsubscribe("test", :reply, "mcollective")
@@ -618,23 +618,24 @@ module MCollective
             end
 
             it "should create correct targets" do
+              Client.stubs(:request_sequence).returns(42)
               connector.make_target("test", :reply, "mcollective").should eq({
-                :name => "/exchange/mcollective_reply/rspec_#{$$}",
+                :name => "/exchange/mcollective_reply/rspec_#{$$}_42",
                 :headers => {},
                 :id => "mcollective_test_replies",
               })
               connector.make_target("test", :broadcast, "mcollective").should eq({
                 :name => "/exchange/mcollective_broadcast/test",
-                :headers => { "reply-to" => "/exchange/mcollective_reply/rspec_#{$$}" },
+                :headers => { "reply-to" => "/exchange/mcollective_reply/rspec_#{$$}_42" },
                 :id => "mcollective_broadcast_test"
               })
               connector.make_target("test", :request, "mcollective").should eq({
                 :name => "/exchange/mcollective_broadcast/test",
-                :headers => { "reply-to" => "/exchange/mcollective_reply/rspec_#{$$}" },
+                :headers => { "reply-to" => "/exchange/mcollective_reply/rspec_#{$$}_42" },
                 :id => "mcollective_broadcast_test",
               })
               connector.make_target("test", :direct_request, "mcollective", nil, "rspec").should eq({
-                :headers => { "reply-to" => "/exchange/mcollective_reply/rspec_#{$$}" },
+                :headers => { "reply-to" => "/exchange/mcollective_reply/rspec_#{$$}_42" },
                 :name => "/exchange/mcollective_directed/rspec",
                 :id => nil
               })

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

@@ -0,0 +1,92 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+require File.dirname(__FILE__) + "/../../../../../plugins/mcollective/data/fact_data.rb"
+
+module MCollective
+  module Data
+    describe Fact_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 = Fact_data.new
+
+          facts_plugin = mock('fact_plugin')
+          PluginManager.stubs(:[]).with('facts_plugin').returns(facts_plugin)
+
+          facts_plugin.expects(:get_facts).returns({
+            "foo" => "foo-value",
+            "one" => {
+              "one" => "one-one",
+              "two" => {
+                "one" => "one-two-one",
+                "two" => "one-two-two",
+              },
+            },
+            "some_array" => [
+              "a",
+              "b",
+            ],
+          })
+        end
+
+        it 'should return an unfound fact as false' do
+          @plugin.query_data("bar")
+
+          @plugin.result[:exists].should == false
+          @plugin.result[:value].should == false
+          @plugin.result[:value_encoding].should == false
+        end
+
+        it "should be able to find a value at top level" do
+          @plugin.query_data("foo")
+
+          @plugin.result[:exists].should == true
+          @plugin.result[:value].should == "foo-value"
+          @plugin.result[:value_encoding].should == 'text/plain'
+        end
+
+        it 'should be able to walk down to a hash element' do
+          @plugin.query_data("one.one")
+
+          @plugin.result[:exists].should == true
+          @plugin.result[:value].should == "one-one"
+          @plugin.result[:value_encoding].should == 'text/plain'
+        end
+
+        it 'should be able to walk down to a hash' do
+          @plugin.query_data("one.two")
+
+          @plugin.result[:exists].should == true
+
+          @plugin.result[:value].should == {
+            "one" => "one-two-one",
+            "two" => "one-two-two",
+          }.to_json
+          @plugin.result[:value_encoding].should == 'application/json'
+
+        end
+
+        it 'should be able to walk down to an array' do
+          @plugin.query_data("some_array")
+
+          @plugin.result[:exists].should == true
+          @plugin.result[:value].should == [ "a", "b" ].to_json
+          @plugin.result[:value_encoding].should == 'application/json'
+        end
+
+        it 'should be able to walk down to an array element' do
+          @plugin.query_data("some_array.0")
+
+          @plugin.result[:exists].should == true
+          @plugin.result[:value].should == "a"
+          @plugin.result[:value_encoding].should == 'text/plain'
+        end
+      end
+    end
+  end
+end

data/spec/unit/registration/base_spec.rb

@@ -5,6 +5,9 @@ require 'spec_helper'
 module MCollective
   module Registration
     describe Base do
+
+      let(:connection) { mock }
+
       before do
         @config = mock
         @config.stubs(:identity).returns("rspec")
@@ -18,7 +21,20 @@ module MCollective
         it "should provide access the main configuration class" do
           @reg.config.should == @config
         end
+      end
+
+      describe "#run" do
+        it "should not start the publish_thread if the registration interval is 0" do
+          @reg.stubs(:interval).returns(0)
+          Thread.expects(:new).never
+          @reg.run(connection).should == false
+        end
 
+        it "should start the publish_thread" do
+          @reg.stubs(:interval).returns(1)
+          Thread.expects(:new).returns(true)
+          @reg.run(connection).should be_true
+        end
       end
 
       describe "#identity" do
@@ -72,6 +88,36 @@ module MCollective
           @reg.publish("message")
         end
       end
+
+      describe "#body" do
+        it "should fail if body hasn't been implemented" do
+          expect {
+            @reg.body
+          }.to raise_error
+        end
+      end
+
+      describe "#publish_thread" do
+        before(:each) do
+          @reg.expects(:loop).returns("looping")
+        end
+
+        it "should splay if splay is set" do
+          @reg.stubs(:interval).returns(1)
+          @config.stubs(:registration_splay).returns(true)
+          Log.expects(:debug)
+          @reg.expects(:sleep)
+          @reg.send(:publish_thread, connection)
+        end
+
+        it "should not splay if splay isn't set" do
+          @reg.stubs(:interval).returns(1)
+          @config.stubs(:registration_splay).returns(false)
+          Log.expects(:debug).never
+          @reg.expects(:sleep).never
+          @reg.send(:publish_thread, connection)
+        end
+      end
     end
   end
 end

data/spec/unit/rpc/agent_spec.rb

@@ -151,6 +151,43 @@ module MCollective
         end
       end
 
+      describe "#activate?" do
+        class Test < MCollective::RPC::Agent;end
+
+        let(:config) do
+          conf = mock
+          conf.stubs(:pluginconf).returns({})
+          conf
+        end
+
+        before(:each) do
+          Config.stubs(:instance).returns(config)
+          Log.stubs(:debug)
+        end
+
+        it "should return true if plugins are globally enabled" do
+          config.stubs(:activate_agents).returns(true)
+          Test.activate?.should == true
+        end
+
+        it "should return true if plugins are globally disabled but locally enabled" do
+          config.stubs(:activate_agents).returns(false)
+          config.pluginconf['test.activate_agent'] = true
+          Test.activate?.should == true
+        end
+
+        it "should return false if plugins are globally disabled" do
+          config.stubs(:activate_agents).returns(false)
+          Test.activate?.should == false
+        end
+
+        it "should return false if plugins are globally enabled but locally disabled" do
+          config.stubs(:activate_agents).returns(true)
+          config.pluginconf['test.activate_agent'] = false
+          Test.activate?.should == false
+        end
+      end
+
       describe "#load_ddl" do
         it "should load the correct DDL" do
           ddl = stub

data/spec/unit/rpc/client_spec.rb

@@ -102,18 +102,6 @@ module MCollective
           @client.process_results_with_block("rspec", response, blk, nil)
         end
 
-        it "should raise correct exceptions on failure" do
-          blk = Proc.new {}
-
-          @client.stubs(:rpc_result_from_reply)
-
-          [[2, UnknownRPCAction], [3, MissingRPCData], [4, InvalidRPCData], [5, UnknownRPCError]].each do |err|
-            response = {:senderid => "rspec", :body => {:statuscode => err[0]}}
-
-            expect { @client.process_results_with_block("rspec", response, blk, nil) }.to raise_error(err[1])
-          end
-        end
-
         it "should pass raw results for single arity blocks" do
           response = {:senderid => "rspec", :body => {:statuscode => 1}}
           blk = Proc.new {|r| r.should == response}
@@ -560,11 +548,21 @@ module MCollective
           @client.limit_targets.should == 1
         end
 
-        it "should not invalid limits to be set" do
+        it "should not allow 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
+
+        it "should reset @limit_targets" do
+          @client.limit_targets = 10
+          @client.limit_targets.should == 10
+          @client.limit_targets = nil
+          @client.limit_targets.should == nil
+          @client.limit_targets = 10
+          @client.limit_targets = false
+          @client.limit_targets.should == nil
+        end
       end
 
       describe "#fire_and_forget_request" do
@@ -686,12 +684,12 @@ module MCollective
           }.to raise_error("Cannot bypass result processing for batched requests")
         end
 
-        it "should only accept integer batch sizes" do
+        it "should only accept valid 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/)
+          }.to raise_error("batch_size must be an integer or match a percentage string (e.g. '24%'")
         end
 
         it "should only accept float sleep times" do
@@ -825,6 +823,12 @@ module MCollective
           expect { client.batch_size = 5 }.to raise_error("Can only set batch size if direct addressing is supported")
         end
 
+        it "should accept batch sizes as percentage strings" do
+          client = Client.new("foo", {:options => {:filter => Util.empty_filter, :config => "/nonexisting"}})
+          client.batch_size = "50%"
+          client.batch_size.should == "50%"
+        end
+
         it "should support disabling batch mode when supplied a batch size of 0" do
           Config.instance.stubs(:direct_addressing).returns(true)
 
@@ -1011,6 +1015,55 @@ module MCollective
           rpcclient.discover
         end
       end
+
+      describe "#determine_batch_mode" do
+        let(:rpcclient) do
+          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    
+        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   
+        end
+      end
+
+      describe "#validate_batch_size" do
+        let(:rpcclient) do
+          rpcclient = Client.new("foo", 
+                                 {:options => {:filter => Util.empty_filter, 
+                                               :config => "/nonexisting", 
+                                               :verbose => false, 
+                                               :disctimeout => 2}})
+        end
+
+        it "should fail when batch size is an invalid string" do
+          expect {
+            rpcclient.send(:validate_batch_size, "foo")
+          }.to raise_error
+        end
+
+        it "should fail when batch size is 0%" do
+          expect {
+            rpcclient.send(:validate_batch_size, "0%")
+          }.to raise_error
+        end
+
+        it "should fail when batch size is not a valid string or integer" do
+          expect {
+            rpcclient.send(:validate_batch_size, true)
+          }.to raise_error
+        end
+      end
     end
   end
 end