mcollective-client 2.2.4 → 2.4.0

data/spec/unit/config_spec.rb

@@ -5,6 +5,34 @@ require 'spec_helper'
 module MCollective
   describe Config do
     describe "#loadconfig" do
+      it "should fail when no libdir is set" do
+        File.expects(:exists?).with("/nonexisting").returns(true)
+        File.expects(:readlines).with("/nonexisting").returns([])
+        Config.instance.stubs(:set_config_defaults)
+        expect { Config.instance.loadconfig("/nonexisting") }.to raise_error("The /nonexisting config file does not specify a libdir setting, cannot continue")
+      end
+
+      it "should only test that libdirs are absolute paths" do
+        Util.expects(:absolute_path?).with("/one").returns(true)
+        Util.expects(:absolute_path?).with("/two").returns(true)
+        Util.expects(:absolute_path?).with("/three").returns(true)
+        Util.expects(:absolute_path?).with("four").returns(false)
+
+        File.stubs(:exists?).with("/nonexisting").returns(true)
+
+        ["/one#{File::PATH_SEPARATOR}/two", "/three"].each do |path|
+          File.expects(:readlines).with("/nonexisting").returns(["libdir = #{path}"])
+
+          Config.instance.loadconfig("/nonexisting")
+
+          PluginManager.clear
+        end
+
+        File.expects(:readlines).with("/nonexisting").returns(["libdir = four"])
+
+        expect { Config.instance.loadconfig("/nonexisting") }.to raise_error(/should be absolute paths/)
+      end
+
       it "should not allow any path like construct for identities" do
         # Taken from puppet test cases
         ['../foo', '..\\foo', './../foo', '.\\..\\foo',
@@ -16,9 +44,8 @@ module MCollective
           "\\\\?\\c:\\foo", "//?/UNC/bar", "//foo/bar",
           "//?/c:/foo"
         ].each do |input|
-          File.expects(:open).with("/nonexisting", "r").returns(StringIO.new("identity = #{input}"))
+          File.expects(:readlines).with("/nonexisting").returns(["identity = #{input}", "libdir=/nonexistinglib"])
           File.expects(:exists?).with("/nonexisting").returns(true)
-          File.expects(:exists?).with(File.join(File.dirname("/nonexisting"), "rpc-help.erb")).returns(true)
 
           expect {
             Config.instance.loadconfig("/nonexisting")
@@ -26,11 +53,19 @@ module MCollective
         end
       end
 
+      it "should strip whitespaces from config keys" do
+        File.expects(:exists?).with("/nonexisting").returns(true)
+        File.expects(:readlines).with("/nonexisting").returns([" identity= your.example.com  ", "libdir=/nonexisting"])
+
+        config = Config.instance
+        config.loadconfig("/nonexisting")
+        config.identity.should == "your.example.com"
+      end
+
       it "should allow valid identities" do
         ["foo", "foo_bar", "foo-bar", "foo-bar-123", "foo.bar", "foo_bar_123"].each do |input|
-          File.expects(:open).with("/nonexisting", "r").returns(StringIO.new("identity = #{input}"))
+          File.expects(:readlines).with("/nonexisting").returns(["identity = #{input}", "libdir=/nonexistinglib"])
           File.expects(:exists?).with("/nonexisting").returns(true)
-          File.expects(:exists?).with(File.join(File.dirname("/nonexisting"), "rpc-help.erb")).returns(true)
           PluginManager.stubs(:loadclass)
           PluginManager.stubs("<<")
 
@@ -38,54 +73,74 @@ module MCollective
         end
       end
 
-      it "should not allow the syslog logger type on windows" do
-        Util.expects("windows?").returns(true).twice
-        File.expects(:open).with("/nonexisting", "r").returns(StringIO.new("logger_type = syslog"))
+      it "should set direct_addressing to true by default" do
+        File.expects(:readlines).with("/nonexisting").returns(["libdir=/nonexistinglib"])
         File.expects(:exists?).with("/nonexisting").returns(true)
-        File.expects(:exists?).with(File.join(File.dirname("/nonexisting"), "rpc-help.erb")).returns(true)
         PluginManager.stubs(:loadclass)
         PluginManager.stubs("<<")
 
-        expect { Config.instance.loadconfig("/nonexisting") }.to raise_error("The sylog logger is not usable on the Windows platform")
+        Config.instance.loadconfig("/nonexisting")
+        Config.instance.direct_addressing.should == true
       end
 
-      it "should default to finding the help template in the same dir as the config file" do
-        path = File.join(File.dirname("/nonexisting"), "rpc-help.erb")
-
-        File.expects(:open).with("/nonexisting", "r").returns(StringIO.new(""))
+      it "should allow direct_addressing to be disabled in the config file" do
+        File.expects(:readlines).with("/nonexisting").returns(["libdir=/nonexistinglib", "direct_addressing=n"])
         File.expects(:exists?).with("/nonexisting").returns(true)
         PluginManager.stubs(:loadclass)
         PluginManager.stubs("<<")
 
-        File.expects(:exists?).with(path).returns(true)
-
         Config.instance.loadconfig("/nonexisting")
-        Config.instance.rpchelptemplate.should == path
+        Config.instance.direct_addressing.should == false
       end
 
-      it "should fall back to old behavior if the help template file does not exist in the config dir" do
-        path = File.join(File.dirname("/nonexisting"), "rpc-help.erb")
-
-        File.expects(:open).with("/nonexisting", "r").returns(StringIO.new(""))
+      it "should not allow the syslog logger type on windows" do
+        Util.expects("windows?").returns(true).twice
+        File.expects(:readlines).with("/nonexisting").returns(["libdir=/nonexistinglib", "logger_type=syslog"])
         File.expects(:exists?).with("/nonexisting").returns(true)
-        File.expects(:exists?).with(path).returns(false)
         PluginManager.stubs(:loadclass)
         PluginManager.stubs("<<")
 
-        Config.instance.loadconfig("/nonexisting")
-        Config.instance.rpchelptemplate.should == "/etc/mcollective/rpc-help.erb"
+        expect { Config.instance.loadconfig("/nonexisting") }.to raise_error("The sylog logger is not usable on the Windows platform")
       end
 
       it "should support multiple default_discovery_options" do
-        File.expects(:open).with("/nonexisting", "r").returns(StringIO.new("default_discovery_options = 1\ndefault_discovery_options = 2"))
+        File.expects(:readlines).with("/nonexisting").returns(["default_discovery_options = 1", "default_discovery_options = 2", "libdir=/nonexistinglib"])
         File.expects(:exists?).with("/nonexisting").returns(true)
-        File.expects(:exists?).with(File.join(File.dirname("/nonexisting"), "rpc-help.erb")).returns(true)
         PluginManager.stubs(:loadclass)
         PluginManager.stubs("<<")
 
         Config.instance.loadconfig("/nonexisting")
         Config.instance.default_discovery_options.should == ["1", "2"]
       end
+
+      it "should not allow non integer values when expecting an integer value" do
+        PluginManager.stubs(:loadclass)
+        PluginManager.stubs("<<")
+
+        ["registerinterval", "max_log_size", "direct_addressing_threshold", "publish_timeout",
+         "fact_cache_time", "ttl"].each do |key|
+          File.expects(:readlines).with("/nonexisting").returns(["#{key} = nan"])
+          File.expects(:exists?).with("/nonexisting").returns(true)
+
+          expect{
+            Config.instance.loadconfig("/nonexisting")
+          }.to raise_error "Could not parse value for configuration option '#{key}' with value 'nan'"
+         end
+      end
+
+      it 'should log a warning when using a deprecated option' do
+        PluginManager.stubs(:loadclass)
+        PluginManager.stubs("<<")
+
+        ["topicprefix", "topicsep", "queueprefix", "rpchelptemplate", "helptemplatedir"].each do |key|
+          File.expects(:exists?).with("/nonexisting").returns(true)
+          File.expects(:readlines).with("/nonexisting").returns(["#{key} = nan", "libdir = /nonexistinglib"])
+
+          Log.stubs(:warn)
+          Log.expects(:warn).with("Use of deprecated '#{key}' option.  This option is ignored and should be removed from '/nonexisting'")
+          Config.instance.loadconfig("/nonexisting")
+        end
+      end
     end
 
     describe "#read_plugin_config_dir" do
@@ -124,6 +179,13 @@ module MCollective
         Config.instance.pluginconf.should == {"foo.rspec" => "test"}
       end
 
+      it "should strip whitespaces from config keys" do
+        Dir.expects(:new).with(@plugindir).returns(["foo.cfg"])
+        File.expects(:open).with(File.join(@plugindir, "foo.cfg"), "r").returns(["   rspec  = test"])
+        Config.instance.read_plugin_config_dir(@plugindir)
+        Config.instance.pluginconf.should == {"foo.rspec" => "test"}
+      end
+
       it "should override main config file" do
         configfile = File.join(@plugindir, "foo.cfg")
         servercfg = File.join(File.dirname(@plugindir), "server.cfg")
@@ -133,7 +195,8 @@ module MCollective
         File.stubs(:exists?).returns(true)
         File.stubs(:directory?).with(@plugindir).returns(true)
         File.stubs(:exists?).with(servercfg).returns(true)
-        File.expects(:open).with(servercfg, "r").returns(["plugin.rspec.key = default"])
+        File.expects(:readlines).with(servercfg).returns(["plugin.rspec.key = default", "libdir=/nonexisting"])
+        File.stubs(:directory?).with("/nonexisting").returns(true)
 
         Dir.expects(:new).with(@plugindir).returns(["rspec.cfg"])
         File.expects(:open).with(File.join(@plugindir, "rspec.cfg"), "r").returns(["key = overridden"])

data/spec/unit/data/base_spec.rb

@@ -7,6 +7,7 @@ module MCollective
     describe Base do
       before do
         @ddl = mock
+        @ddl.stubs(:dataquery_interface).returns({:output => {'rspec' => {}}})
         @ddl.stubs(:meta).returns({:timeout => 1})
       end
 

data/spec/unit/data/result_spec.rb

@@ -6,7 +6,21 @@ module MCollective
   module Data
     describe Result do
       before(:each) do
-        @result = Result.new
+        @result = Result.new({})
+      end
+
+      describe "#initialize" do
+        it "should initialize empty values for all output fields" do
+          result = Result.new({:rspec1 => {}, :rspec2 => {}})
+          result[:rspec1].should == nil
+          result[:rspec2].should == nil
+        end
+
+        it "should set default values for all output fields" do
+          result = Result.new({:rspec1 => {:default => 1}, :rspec2 => {}})
+          result[:rspec1].should == 1
+          result[:rspec2].should == nil
+        end
       end
 
       describe "#[]=" do
@@ -58,6 +72,10 @@ module MCollective
       end
 
       describe "#method_missing" do
+        it "should raise the correct exception for unknown keys" do
+          expect { @result.nosuchdata }.to raise_error(NoMethodError)
+        end
+
         it "should retrieve the correct data" do
           @result["rspec"] = "rspec value"
           @result.rspec.should == "rspec value"

data/spec/unit/data_spec.rb

@@ -17,6 +17,8 @@ module MCollective
 
         ddl = mock
         ddl.stubs(:meta).returns({:timeout => 1})
+        ddl.stubs(:dataquery_interface).returns({:rspec => nil})
+        ddl.stubs(:dataquery_interface).returns({:output => {}})
         DDL.stubs(:new).returns(ddl)
         Data::Base.expects(:activate?).returns(false)
         PluginManager.expects("[]").with("rspec_data").returns(Data::Base.new)
@@ -30,6 +32,7 @@ module MCollective
 
         ddl = mock
         ddl.stubs(:meta).returns({:timeout => 1})
+        ddl.stubs(:dataquery_interface).returns({:output => {}})
         DDL.stubs(:new).returns(ddl)
         Data::Base.expects(:activate?).raises("rspec failure")
         Log.expects(:debug).once.with("Disabling data plugin rspec_data due to exception RuntimeError: rspec failure")

data/spec/unit/ddl/agentddl_spec.rb

@@ -17,6 +17,36 @@ module MCollective
         end
       end
 
+      describe "#set_default_input_arguments" do
+        before do
+          @ddl.action(:test, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :test)
+
+          @ddl.input(:optional, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "",
+                     :maxlength => 1, :default => "default")
+          @ddl.input(:required, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => false, :validation => "",
+                     :maxlength => 1, :default => "default")
+        end
+
+        it "should correctly add default arguments to required inputs" do
+          args = {}
+
+          @ddl.set_default_input_arguments(:test, args)
+
+          args.should == {:required => "default"}
+        end
+
+        it "should not override any existing arguments" do
+          args = {:required => "specified"}
+
+          @ddl.set_default_input_arguments(:test, args)
+
+          args.should == {:required => "specified"}
+        end
+      end
+
       describe "#validate_rpc_request" do
         it "should ensure the action is known" do
           @ddl.action(:test, :description => "rspec")
@@ -38,6 +68,8 @@ module MCollective
                      :type => :string, :optional => false, :validation => "",
                      :maxlength => 1)
 
+          @ddl.stubs(:validate_input_argument).returns(true)
+
           expect {
             @ddl.validate_rpc_request(:test, {})
           }.to raise_error("Action test needs a required argument")

data/spec/unit/ddl/base_spec.rb

@@ -18,6 +18,8 @@ module MCollective
 
         it "should return correct new path for other ddls" do
           @ddl.instance_variable_set("@plugintype", :data)
+          @ddl.stubs(:helptemplatedir).returns("/etc/mcollective")
+          Util.stubs(:templatepath).with("data-help.erb").returns("/etc/mcollective/data-help.erb")
           File.expects(:exists?).with("/etc/mcollective/data-help.erb").returns(true)
           @ddl.template_for_plugintype.should == "data-help.erb"
         end
@@ -31,6 +33,8 @@ module MCollective
         end
 
         it "should use template from help template path when provided template name is not an absolute file path" do
+          Util.stubs(:absolute_path?).returns(false)
+          Util.stubs(:templatepath).returns("/etc/mcollective/foo", "/etc/mcollective/metadata-help.erb")
           File.expects(:read).with("/etc/mcollective/foo").returns("rspec")
           File.expects(:read).with("/etc/mcollective/metadata-help.erb").returns("rspec")
           @ddl.help("foo").should == "rspec"

data/spec/unit/ddl/dataddl_spec.rb

@@ -34,7 +34,7 @@ module MCollective
           end
 
           @ddl.dataquery_interface.should == {:description => "rspec",
-                                              :input => {:query => input.merge(:optional => nil)},
+                                              :input => {:query => input.merge(:optional => nil, :default => nil)},
                                               :output => {:rspec => output}}
         end
       end

data/spec/unit/log_spec.rb

@@ -10,9 +10,17 @@ module MCollective
       @logger.stubs(:start)
       @logger.stubs(:set_logging_level)
       @logger.stubs(:valid_levels)
+      @logger.stubs(:new).returns(@logger)
+
+      # we stub it out at the top of the test suite
+      Log.unstub(:log)
+      Log.unstub(:logexception)
+      Log.unstub(:logmsg)
+
+      Log.set_logger(@logger)
     end
 
-    describe "#cofigure" do
+    describe "#configure" do
       it "should default to console logging if called prior to configuration" do
         Config.instance.instance_variable_set("@configured", false)
         Log.configure
@@ -28,43 +36,52 @@ module MCollective
     end
 
     describe "#log" do
-      it "should log at debug level" do
-        @logger.expects(:log).with(:debug, anything, regexp_matches(/debug test/))
-        Log.configure(@logger)
-        Log.debug("debug test")
+      it "should log at the right levels" do
+        [:debug, :info, :fatal, :error, :warn].each do |level|
+          @logger.expects(:log).with(level, anything, regexp_matches(/#{level} test/))
+          Log.send(level, "#{level} test")
+        end
       end
+    end
 
-      it "should log at info level" do
-        @logger.expects(:log).with(:info, anything, regexp_matches(/info test/))
-        Log.configure(@logger)
-        Log.info("info test")
-      end
+    describe "#cycle_level" do
+      it "should cycle logger class levels" do
+        @logger.expects(:cycle_level)
 
-      it "should log at fatal level" do
-        @logger.expects(:log).with(:fatal, anything, regexp_matches(/fatal test/))
         Log.configure(@logger)
-        Log.fatal("fatal test")
+        Log.cycle_level
       end
+    end
 
-      it "should log at error level" do
-        @logger.expects(:log).with(:error, anything, regexp_matches(/error test/))
-        Log.configure(@logger)
-        Log.error("error test")
+    describe "#from" do
+      let(:execution_stack) do
+        if Util.windows?
+          ['C:\rspec\test1:52:in `rspec block1\'',
+           'C:\rspec\test2:52:in `rspec block2\'',
+           'C:\rspec\test3:52:in `rspec block3\'',
+           'C:\rspec\test4:52:in `rspec block4\'']
+        else
+          ["/rspec/test1:52:in `rspec block1'",
+           "/rspec/test2:52:in `rspec block2'",
+           "/rspec/test3:52:in `rspec block3'",
+           "/rspec/test4:52:in `rspec block4'"]
+        end
       end
 
-      it "should log at warning level" do
-        @logger.expects(:log).with(:warn, anything, regexp_matches(/warn test/))
-        Log.configure(@logger)
-        Log.warn("warn test")
+      it "should return the correct from string when given file, line, block" do
+        Log.stubs(:execution_stack).returns(execution_stack)
+        Log.from.should == "test4:52:in `rspec block4'"
       end
-    end
 
-    describe "#cycle_level" do
-      it "should cycle logger class levels" do
-        @logger.expects(:cycle_level)
+      it "should return the correct from string shen given file and line" do
+        if Util.windows?
+          execution_stack[3] = 'C:\rspec\test4:52'
+        else
+          execution_stack[3] = '/rspec/test4:52'
+        end
 
-        Log.configure(@logger)
-        Log.cycle_level
+        Log.stubs(:execution_stack).returns(execution_stack)
+        Log.from.should == "test4:52"
       end
     end
   end

data/spec/unit/logger/base_spec.rb

@@ -23,7 +23,7 @@ module MCollective::Logger
       end
 
       it "should accept correct levels" do
-        Base.new
+        expect { Base.new }.to_not raise_error
       end
     end
 

data/spec/unit/matcher_spec.rb

@@ -117,6 +117,14 @@ module MCollective
         result = Matcher.execute_function({"name" => "foo", "params" => "bar"})
         result.should == "success"
       end
+
+      it "should return nil if the result cannot be evaluated" do
+        data = mock
+        data.expects(:send).with("value").raises("error")
+        Data.expects(:send).with("foo", "bar").returns(data)
+        result = Matcher.execute_function({"name" => "foo", "params" => "bar", "value" => "value"})
+        result.should == nil
+      end
     end
 
     describe "#eval_compound_statement" do
@@ -170,6 +178,12 @@ module MCollective
           result = Matcher.eval_compound_fstatement(function_hash)
           result.should == false
         end
+
+        it "should return false immediately if the function execution returns nil" do
+          Matcher.expects(:execute_function).returns(nil)
+          result = Matcher.eval_compound_fstatement(function_hash)
+          result.should == false
+        end
       end
 
       describe "it should return false if backticks are present in parameters and if non strings are compared with regex's" do