mcollective-client 2.2.4 → 2.4.0

data/spec/unit/plugins/mcollective/agent/rpcutil_spec.rb

@@ -0,0 +1,176 @@
+#!/usr/bin/env rspec
+
+@agent_file = File.join(File.dirname(__FILE__), '../../../../../', 'plugins', 'mcollective', 'agent', 'rpcutil.rb')
+
+require 'spec_helper'
+require @agent_file
+
+module MCollective
+  module Agent
+    describe Rpcutil do
+      module Facts
+        def self.[](fact)
+          {'fact1' => 'value1', 'fact2' => 'value2', 'fact3' => 'value3'}[fact]
+        end
+      end
+
+      before :each do
+        @agent = MCollective::Test::LocalAgentTest.new('rpcutil', :agent_file => @agent_file).plugin
+      end
+
+      describe '#inventory' do
+        it 'should return the node inventory' do
+          facts = mock
+          facts.stubs(:get_facts).returns({:key => 'value'})
+          Agents.stubs(:agentlist).returns(['test'])
+          PluginManager.stubs(:[]).with('facts_plugin').returns(facts)
+          MCollective.stubs(:version).returns('2.4.0')
+          PluginManager.stubs(:grep).with(/_data$/).returns(['test_data'])
+          Config.any_instance.stubs(:classesfile).returns('classes.txt')
+          File.stubs(:exist?).with('classes.txt').returns(true)
+          File.stubs(:readlines).with('classes.txt').returns(['class1', 'class2'])
+          result = @agent.call(:inventory)
+          result.should be_successful
+          result.should have_data_items({:agents=>["test"],
+                                        :facts=>{:key=>"value"},
+                                        :version=>"2.4.0",
+                                        :classes=>["class1", "class2"],
+                                        :main_collective=>"mcollective",
+                                        :collectives=>["production", "staging"],
+                                        :data_plugins=>["test_data"]})
+        end
+      end
+
+      describe '#get_fact' do
+        it 'should return the value of the queried fact' do
+          result = @agent.call(:get_fact, :fact => 'fact1')
+          result.should be_successful
+          result.should have_data_items({:fact => 'fact1', :value => 'value1'})
+        end
+
+        it 'should not break if the fact is not present' do
+          result = @agent.call(:get_fact, :fact => 'fact4')
+          result.should be_successful
+          result.should have_data_items({:fact => 'fact4', :value => nil })
+        end
+      end
+
+      describe '#get_facts' do
+        it 'should return the value of the supplied facts' do
+          result = @agent.call(:get_facts, :facts => 'fact1, fact3')
+          result.should be_successful
+          result.should have_data_items(:values => {'fact1' => 'value1', 'fact3' => 'value3'})
+        end
+
+        it 'should not break if the facts are not present' do
+          result = @agent.call(:get_facts, :facts => 'fact4, fact5')
+          result.should be_successful
+          result.should have_data_items(:values => {'fact4' => nil, 'fact5' => nil})
+        end
+      end
+
+      describe '#daemon_stats' do
+        it "it should return the daemon's statistics" do
+          stats = {:threads => 2,
+                   :agents => ['agent1', 'agent2'],
+                   :pid => 42,
+                   :times => 12345,
+                   :configfile => '/etc/mcollective/server.cfg',
+                   :version => '2.4.0',
+                   :stats => {}}
+          config = mock
+          Config.stubs(:instance).returns(config)
+          MCollective.stubs(:version).returns('2.4.0')
+          config.stubs(:configfile).returns('/etc/mcollective/server.cfg')
+          PluginManager.stubs(:[]).returns(stats)
+          result = @agent.call(:daemon_stats)
+          result.should be_successful
+          stats.delete(:stats)
+          result.should have_data_items(stats)
+        end
+      end
+
+      describe '#agent_inventory' do
+        it 'should return the agent inventory' do
+          meta = {:license => 'ASL 2',
+                  :description => 'Agent for testing',
+                  :url => 'http://www.theurl.net',
+                  :version => '1',
+                  :author => 'rspec'}
+          agent = mock
+          agent.stubs(:meta).returns(meta)
+          agent.stubs(:timeout).returns(2)
+          PluginManager.stubs(:[]).with('test_agent').returns(agent)
+          Agents.stubs(:agentlist).returns(['test'])
+
+          result = @agent.call(:agent_inventory)
+          result.should be_successful
+          result.should have_data_items(:agents => [meta.merge({:timeout => 2, :name => 'test', :agent => 'test'})])
+        end
+      end
+
+      describe '#get_config_item' do
+        it 'should return the value of the requested config item' do
+          Config.any_instance.stubs(:respond_to?).with(:main_collective).returns(true)
+          result = @agent.call(:get_config_item, :item => :main_collective)
+          result.should be_successful
+          result.should have_data_items(:item => :main_collective, :value => "mcollective")
+        end
+
+        it 'should fail if the config item has not been defined' do
+          result = @agent.call(:get_config_item, :item => :failure)
+          result.should be_aborted_error
+        end
+      end
+
+      describe '#ping' do
+        it 'should return the current time on the host' do
+          Time.expects(:now).returns("123456")
+          result = @agent.call(:ping)
+          result.should be_successful
+          result.should have_data_items(:pong => 123456)
+        end
+      end
+
+      describe '#collective_info' do
+        it 'should return the main collective and list of defined collectives' do
+          result = @agent.call(:collective_info)
+          result.should be_successful
+          result.should have_data_items({:main_collective => 'mcollective', :collectives => ['production', 'staging']})
+        end
+      end
+
+      describe '#get_data' do
+        let(:query_data) do
+          {:key1 => 'value1', :key2 => 'value2'}
+        end
+
+        let(:data) do
+          mock
+        end
+
+        let(:ddl) do
+          mock
+        end
+
+        it 'should return the data results if a query has been specified' do
+          data.stubs(:lookup).with('query').returns(query_data)
+          Data.stubs(:ddl).with('test_data').returns(ddl)
+          Data.stubs(:ddl_transform_input).with(ddl, 'query').returns('query')
+          Data.stubs(:[]).with('test_data').returns(data)
+          result = @agent.call(:get_data, :source => 'test_data', :query => 'query')
+          result.should be_successful
+          result.should have_data_items(:key1 => 'value1', :key2 => 'value2')
+        end
+
+        it 'should return the data results if no query has been specified' do
+          data.stubs(:lookup).with(nil).returns(query_data)
+          Data.stubs(:[]).with('test_data').returns(data)
+          result = @agent.call(:get_data, :source => 'test_data')
+          result.should be_successful
+          result.should have_data_items(:key1 => 'value1', :key2 => 'value2')
+        end
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/application/plugin_spec.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+require File.join(File.dirname(__FILE__), '../../../../../', 'plugins', 'mcollective', 'application', 'plugin.rb')
+
+module MCollective
+  class Application
+    describe Plugin do
+
+      let(:ddl) { mock }
+
+      before do
+        @app = MCollective::Application::Plugin.new()
+        @app.configuration[:rpctemplate] = "rspec-helptemplate.erb"
+      end
+
+      describe "#doc_command" do
+        it "should display doc output for a plugin that exists when using 'plugin'" do
+          @app.configuration[:target] = "rspec"
+          PluginManager.stubs(:find).with(:agent, "ddl").returns(["rspec"])
+          PluginManager.stubs(:find).with(:aggregate, "ddl").returns([""])
+          PluginManager.stubs(:find).with(:data, "ddl").returns([""])
+          PluginManager.stubs(:find).with(:discovery, "ddl").returns([""])
+          PluginManager.stubs(:find).with(:validator, "ddl").returns([""])
+          @app.stubs(:load_plugin_ddl).with('rspec', :agent).returns(ddl)
+          ddl.expects(:help).with("rspec-helptemplate.erb").returns("agent_template")
+          @app.expects(:puts).with("agent_template")
+          @app.doc_command
+        end
+
+        it "should display doc output for a plugin that exists when using 'plugintype/plugin'" do
+          @app.configuration[:target] = "agent/rspec"
+          @app.stubs(:load_plugin_ddl).with(:rspec, "agent").returns(ddl)
+          ddl.expects(:help).with("rspec-helptemplate.erb").returns("agent_template")
+          @app.expects(:puts).with("agent_template")
+          @app.doc_command
+        end
+
+        it "should display a failure message for a plugin that doesn't exist when using 'plugin'" do
+          @app.configuration[:target] = "rspec"
+          PluginManager.stubs(:find).returns([""])
+          @app.expects(:abort).with("Could not find a plugin named 'rspec' in any supported plugin type").raises("test_error")
+
+          expect{
+            @app.doc_command
+          }.to raise_error "test_error"
+        end
+
+        it "should display a failure message for a plugin that doens't exist when using 'plugintype/plugin'" do
+          @app.configuration[:target] = "agent/rspec"
+          @app.expects(:load_plugin_ddl).with(:rspec, "agent").returns(nil)
+          @app.expects(:abort).with("Could not find a 'agent' plugin named 'rspec'").raises("test_error")
+
+          expect{
+            @app.doc_command
+          }.to raise_error "test_error"
+        end
+
+        it "should display a failure message if duplicate plugins are found" do
+          @app.configuration[:target] = "rspec"
+          PluginManager.stubs(:find).returns(["rspec"])
+          @app.stubs(:abort).with("Duplicate plugin name found, please specify a full path like agent/rpcutil").raises("test_error")
+
+          expect{
+            @app.doc_command
+          }.to raise_error "test_error"
+        end
+
+        it "should display a failure message for a plugintype that doens't exist" do
+          @app.configuration[:target] = "foo/rspec"
+          @app.stubs(:load_plugin_ddl).with(:rspec, "foo").returns(nil)
+          @app.stubs(:abort).with("Could not find a 'foo' plugin named 'rspec'").raises("test_error")
+
+          expect{
+            @app.doc_command
+          }.to raise_error "test_error"
+        end
+     end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/audit/logfile_spec.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+require File.join(File.dirname(__FILE__), '../../../../../', 'plugins', 'mcollective', 'audit', 'logfile.rb')
+
+module MCollective
+  module RPC
+    describe Logfile do
+      let(:file) do
+        mock
+      end
+
+      let(:request) do
+        req = mock
+        req.stubs(:uniqid).returns("1234")
+        req.stubs(:time).returns(1389179593)
+        req.stubs(:caller).returns("test_user")
+        req.stubs(:sender).returns("test_host")
+        req.stubs(:agent).returns("rspec_agent")
+        req.stubs(:action).returns("testme")
+        req.stubs(:data).returns({})
+        req
+      end
+
+      before :each do
+        Time.stubs(:now).returns(Time.at(1389180255))
+        file.expects(:puts).with("[2014-01-08 11:24:15 UTC] reqid=1234: reqtime=1389179593 caller=test_user@test_host " +
+                                  "agent=rspec_agent action=testme data={}")
+      end
+
+      it 'should log to a user defined logfile' do
+        Config.any_instance.stubs(:pluginconf).returns("rpcaudit.logfile" => "/nonexisting")
+        File.expects(:open).with("/nonexisting", "a").yields(file)
+        Logfile.new.audit_request(request, nil)
+      end
+
+      it 'should log to a default logfile' do
+        Config.any_instance.stubs(:pluginconf).returns({})
+        File.expects(:open).with("/var/log/mcollective-audit.log", "a").yields(file)
+        Logfile.new.audit_request(request, nil)
+      end
+    end
+  end
+end

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

@@ -95,6 +95,8 @@ module MCollective
                         "activemq.randomize" => "true",
                         "activemq.backup" => "true",
                         "activemq.timeout" => "1",
+                        "activemq.max_hbrlck_fails" => 3,
+                        "activemq.max_hbread_fails" => 3,
                         "activemq.connect_timeout" => "5"}
 
 
@@ -114,9 +116,12 @@ module MCollective
                                        :use_exponential_back_off => false,
                                        :max_reconnect_attempts => 5,
                                        :initial_reconnect_delay => 0.02,
+                                       :max_hbread_fails => 3,
+                                       :max_hbrlck_fails => 3,
                                        :randomize => true,
                                        :reliable => true,
                                        :logger => "logger",
+                                       :connect_headers => {},
                                        :hosts => [{:passcode => 'password1',
                                                    :host => 'host1',
                                                    :port => 6163,
@@ -130,12 +135,56 @@ module MCollective
           ])
 
           @c.expects(:ssl_parameters).with(2, true).returns(true)
+          @c.expects(:connection_headers).returns({})
 
           @c.instance_variable_set("@connection", nil)
           @c.connect(connector)
         end
       end
 
+      describe "#connection_headers" do
+        before do
+          @c.stubs(:stomp_version).returns("1.2.10")
+        end
+
+        it "should default to stomp 1.0 only" do
+          @config.expects(:pluginconf).returns({}).at_least_once
+          @c.connection_headers[:"accept-version"] == "1.0"
+        end
+
+        it "should support setting the vhost" do
+          @config.expects(:pluginconf).returns("activemq.vhost" => "rspec").at_least_once
+          @c.connection_headers.should == {:host => "rspec", :"accept-version" => "1.0"}
+        end
+
+        it "should log a warning about not using Stomp 1.1" do
+          @config.expects(:pluginconf).returns("activemq.heartbeat_interval" => "0").at_least_once
+          Log.expects(:warn).with(regexp_matches(/without STOMP 1.1 heartbeats/))
+          @c.connection_headers
+        end
+
+        it "should not support stomp 1.1 with older versions of the stomp gem" do
+          @config.expects(:pluginconf).returns("activemq.heartbeat_interval" => "30").at_least_once
+          @c.expects(:stomp_version).returns("1.0.0").once
+          expect { @c.connection_headers }.to raise_error("Setting STOMP 1.1 properties like heartbeat intervals require at least version 1.2.10 of the STOMP gem")
+        end
+
+        it "should force the heartbeat to min 30 seconds" do
+          @config.expects(:pluginconf).returns("activemq.heartbeat_interval" => "10").at_least_once
+          @c.connection_headers[:"heart-beat"].should == "30500,29500"
+        end
+
+        it "should default to 1.0 and 1.1 support" do
+          @config.expects(:pluginconf).returns("activemq.heartbeat_interval" => "30").at_least_once
+          @c.connection_headers[:"accept-version"].should == "1.1,1.0"
+        end
+
+        it "should support stomp 1.1 only operation" do
+          @config.expects(:pluginconf).returns("activemq.heartbeat_interval" => "30", "activemq.stomp_1_0_fallback" => 0).at_least_once
+          @c.connection_headers[:"accept-version"].should == "1.1"
+        end
+      end
+
       describe "#ssl_paramaters" do
         it "should ensure all settings are provided" do
           pluginconf = {"activemq.pool.1.host" => "host1",
@@ -161,6 +210,8 @@ module MCollective
                         "activemq.pool.1.ssl.ca" => "rspec1.ca,rspec2.ca"}
 
           @config.expects(:pluginconf).returns(pluginconf).at_least_once
+          @c.expects(:get_key_file).returns("rspec.key").at_least_once
+          @c.expects(:get_cert_file).returns("rspec.cert").at_least_once
 
           File.expects(:exist?).with("rspec.cert").twice.returns(true)
           File.expects(:exist?).with("rspec.key").twice.returns(true)
@@ -197,6 +248,33 @@ module MCollective
         end
       end
 
+      describe "#get_key_file" do
+        it "should return the filename from the environment variable" do
+          ENV["MCOLLECTIVE_ACTIVEMQ_POOL2_SSL_KEY"] = "/path/to/rspec/env"
+          @c.get_key_file(2).should == "/path/to/rspec/env"
+        end
+
+        it "should return the filename defined in the config file if the environment varialbe doesn't exist" do
+          ENV.delete("MCOLLECTIVE_ACTIVEMQ_POOL2_SSL_KEY")
+          @c.expects(:get_option).with("activemq.pool.2.ssl.key", false).returns("/path/to/rspec/conf")
+          @c.get_key_file(2).should == "/path/to/rspec/conf"
+        end
+
+      end
+
+      describe "#get_cert_file" do
+        it "should return the filename from the environment variable" do
+          ENV["MCOLLECTIVE_ACTIVEMQ_POOL2_SSL_CERT"] = "/path/to/rspec/env"
+          @c.get_cert_file(2).should == "/path/to/rspec/env"
+        end
+
+        it "should return the filename defined in the config file if the environment varialbe doesn't exist" do
+          ENV.delete("MCOLLECTIVE_ACTIVEMQ_POOL2_SSL_CERT")
+          @c.expects(:get_option).with("activemq.pool.2.ssl.cert", false).returns("/path/to/rspec/conf")
+          @c.get_cert_file(2).should == "/path/to/rspec/conf"
+        end
+      end
+
       describe "#receive" do
         it "should receive from the middleware" do
           payload = mock
@@ -376,24 +454,31 @@ module MCollective
         it "should disconnect from the stomp connection" do
           @connection.expects(:disconnect)
           @c.disconnect
+          @c.connection.should == nil
         end
       end
 
       describe "#headers_for" do
-        it "should return empty headers if priority is 0" do
+        it "should not set priority header if priority is 0" do
           message = mock
           message.expects(:type).returns(:foo)
+          message.stubs(:ttl).returns(30)
+
+          Time.expects(:now).twice.returns(Time.at(1368557431))
 
           @c.instance_variable_set("@msgpriority", 0)
-          @c.headers_for(message).should == {}
+          @c.headers_for(message).should_not includes("priority")
         end
 
         it "should return a priority if priority is non 0" do
           message = mock
           message.expects(:type).returns(:foo)
+          message.stubs(:ttl).returns(30)
+
+          Time.expects(:now).twice.returns(Time.at(1368557431))
 
           @c.instance_variable_set("@msgpriority", 1)
-          @c.headers_for(message).should == {"priority" => 1}
+          @c.headers_for(message)["priority"].should == 1
         end
 
         it "should set mc_identity for direct requests" do
@@ -402,10 +487,16 @@ module MCollective
           message.expects(:agent).returns("rspecagent")
           message.expects(:collective).returns("mcollective")
           message.expects(:reply_to).returns(nil)
+          message.stubs(:ttl).returns(30)
+
+          Time.expects(:now).twice.returns(Time.at(1368557431))
 
           @c.instance_variable_set("@msgpriority", 0)
           @c.expects(:make_target).with("rspecagent", :reply, "mcollective").returns({:name => "test"})
-          @c.headers_for(message, "some.node").should == {"mc_identity"=>"some.node", "reply-to"=>"test"}
+
+          headers = @c.headers_for(message, "some.node")
+          headers["mc_identity"].should == "some.node"
+          headers["reply-to"].should == "test"
         end
 
         it "should set a reply-to header for :request type messages" do
@@ -414,10 +505,13 @@ module MCollective
           message.expects(:agent).returns("rspecagent")
           message.expects(:collective).returns("mcollective")
           message.expects(:reply_to).returns(nil)
+          message.stubs(:ttl).returns(30)
+
+          Time.expects(:now).twice.returns(Time.at(1368557431))
 
           @c.instance_variable_set("@msgpriority", 0)
           @c.expects(:make_target).with("rspecagent", :reply, "mcollective").returns({:name => "test"})
-          @c.headers_for(message).should == {"reply-to" => "test"}
+          @c.headers_for(message)["reply-to"].should == "test"
         end
 
         it "should set reply-to correctly if the message defines it" do
@@ -426,9 +520,23 @@ module MCollective
           message.expects(:agent).returns("rspecagent")
           message.expects(:collective).returns("mcollective")
           message.expects(:reply_to).returns("rspec").twice
+          message.stubs(:ttl).returns(30)
 
-          @c.headers_for(message).should == {"reply-to" => "rspec"}
+          Time.expects(:now).twice.returns(Time.at(1368557431))
 
+          @c.headers_for(message)["reply-to"].should == "rspec"
+        end
+
+        it "should set the timestamp and ttl based on the message object" do
+          message = mock
+          message.expects(:type).returns(:foo)
+          message.stubs(:ttl).returns(100)
+
+          Time.expects(:now).twice.returns(Time.at(1368557431))
+
+          headers = @c.headers_for(message)
+          headers["timestamp"].should == "1368557431000"
+          headers["expires"].should == "1368557541000"
         end
       end
 
@@ -504,28 +612,11 @@ module MCollective
       end
 
       describe "#get_bool_option" do
-        it "should return the default if option isnt set" do
-          @config.expects(:pluginconf).returns({}).once
-          @c.get_bool_option("test", "default").should == "default"
-        end
-
-        ["1", "yes", "true"].each do |boolean|
-          it "should map options to true correctly" do
-            @config.expects(:pluginconf).returns({"test" => boolean}).twice
-            @c.get_bool_option("test", "default").should == true
-          end
-        end
-
-        ["0", "no", "false"].each do |boolean|
-          it "should map options to false correctly" do
-            @config.expects(:pluginconf).returns({"test" => boolean}).twice
-            @c.get_bool_option("test", "default").should == false
-          end
-        end
+        it "should use Util::str_to_bool to translate a boolean value found in the config" do
+          @config.expects(:pluginconf).returns({"rspec" => "true"})
+          Util.expects(:str_to_bool).with("true").returns(true)
 
-        it "should return default for non boolean options" do
-          @config.expects(:pluginconf).returns({"test" => "foo"}).twice
-          @c.get_bool_option("test", "default").should == "default"
+          @c.get_bool_option("rspec", "true").should be_true
         end
       end
     end