mcollective-client 2.0.0 → 2.2.0

data/spec/unit/application_spec.rb

@@ -550,12 +550,14 @@ module MCollective
         out = StringIO.new
         @app.stubs(:disconnect)
         @app.stubs(:exit).with(1)
+        @app.stubs(:options).returns({})
 
+        Config.instance.stubs(:color).returns(false)
         e = mock
         e.stubs(:backtrace).returns([])
         e.stubs(:to_s).returns("rspec")
 
-        out.expects(:puts).with("#{$0} failed to run: rspec (Mocha::Mock)")
+        out.expects(:puts).with(regexp_matches(/rspec application failed to run/))
 
         @app.application_failure(e, out)
       end
@@ -564,14 +566,17 @@ module MCollective
         out = StringIO.new
         @app.stubs(:disconnect)
         @app.stubs(:exit).with(1)
+        @app.stubs(:options).returns(nil)
 
+        Config.instance.stubs(:color).returns(false)
         e = mock
         e.stubs(:backtrace).returns(["rspec"])
         e.stubs(:to_s).returns("rspec")
 
         @app.expects(:options).returns({:verbose => true}).twice
-        out.expects(:puts).with("#{$0} failed to run: rspec (Mocha::Mock)")
-        out.expects(:puts).with("\tfrom rspec")
+        out.expects(:puts).with(regexp_matches(/ application failed to run, use -v for full error details/))
+        out.expects(:puts).with(regexp_matches(/from rspec  <---/))
+        out.expects(:puts).with(regexp_matches(/rspec.+Mocha::Mock/))
 
         @app.application_failure(e, out)
       end

data/spec/unit/applications_spec.rb

@@ -111,13 +111,13 @@ module MCollective
     describe "#list" do
       it "should load the configuration" do
         Applications.expects("load_config").returns(true).once
-        Config.any_instance.expects("libdir").returns([@tmpdir])
+        Config.instance.expects("libdir").returns([@tmpdir])
         Applications.list
       end
 
       it "should add found applications to the list" do
         Applications.expects("load_config").returns(true).once
-        Config.any_instance.expects("libdir").returns([@tmpdir])
+        Config.instance.expects("libdir").returns([@tmpdir])
 
         Applications.list.should == ["test"]
       end

data/spec/unit/cache_spec.rb

@@ -0,0 +1,115 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Cache do
+    before do
+      @locks_mutex = Cache.instance_variable_set("@locks_mutex", Mutex.new)
+      @cache_locks = Cache.instance_variable_set("@cache_locks", {})
+      @cache = Cache.instance_variable_set("@cache", {})
+    end
+
+    describe "#setup" do
+      it "should use a mutex to manage access to the cache" do
+        @locks_mutex.expects(:synchronize).yields
+        Cache.setup("x").should == true
+        @cache.should == {"x" => {:max_age => 300.0}}
+      end
+
+      it "should correctly setup a new cache" do
+        @locks_mutex.expects(:synchronize).twice.yields
+        Cache.setup("rspec1", 300)
+        @cache["rspec1"].should == {:max_age => 300.0}
+
+        Cache.setup("rspec2")
+        @cache["rspec2"].should == {:max_age => 300.0}
+      end
+    end
+
+    describe "#has_cache?" do
+      it "should correctly report presense of a cache" do
+        Cache.setup("rspec")
+        Cache.has_cache?("rspec").should == true
+        Cache.has_cache?("fail").should == false
+      end
+    end
+
+    describe "#delete!" do
+      it "should delete the cache and return true" do
+        Cache.setup("rspec")
+        Cache.delete!("rspec").should == true
+      end
+    end
+
+    describe "#write" do
+      it "should detect unknown caches" do
+        expect { Cache.write("rspec", :key, :val) }.to raise_error("No cache called 'rspec'")
+      end
+
+      it "should write to the cache" do
+        time = Time.now
+        Time.expects(:now).returns(time)
+
+        Cache.setup("rspec")
+        Cache.write("rspec", :key, :val).should == :val
+
+        @cache["rspec"][:key][:value].should == :val
+        @cache["rspec"][:key][:cache_create_time].should == time
+      end
+    end
+
+    describe "#read" do
+      it "should read a written entry correctly" do
+        Cache.setup("rspec")
+        Cache.write("rspec", :key, :val)
+        Cache.read("rspec", :key).should == :val
+      end
+
+      it "should raise on expired reads" do
+        Cache.setup("rspec")
+        Cache.write("rspec", :key, :val)
+
+        Cache.expects(:ttl).returns(0)
+
+        expect { Cache.read("rspec", :key) }.to raise_error(/has expired/)
+      end
+    end
+
+    describe "#valid?" do
+      it "should return >0 for valid" do
+        Cache.setup("rspec", 300)
+        Cache.write("rspec", :key, :val)
+        Cache.ttl("rspec", :key).should >= 0
+      end
+
+      it "should return <0 for invalid" do
+        Cache.setup("rspec", 300)
+        Cache.write("rspec", :key, :val)
+
+        time = Time.now + 600
+        Time.expects(:now).returns(time)
+
+        Cache.ttl("rspec", :key).should <= 0
+      end
+    end
+
+    describe "#synchronize" do
+      it "should use the correct mutex" do
+        Cache.setup("rspec")
+
+        rspec_lock = @cache_locks["rspec"]
+        rspec_lock.expects(:synchronize).yields
+
+        @cache_locks.expects("[]").with("rspec").returns(rspec_lock)
+
+        ran = 0
+        Cache.synchronize("rspec") do
+          ran = 1
+        end
+
+        ran.should == 1
+      end
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Client do
+    before do
+      @security = mock
+      @security.stubs(:initiated_by=)
+      @connector = mock
+      @connector.stubs(:connect)
+      @connector.stubs(:subscribe)
+      @connector.stubs(:unsubscribe)
+      @ddl = mock
+      @ddl.stubs(:meta).returns({:timeout => 1})
+      @discoverer = mock
+
+      Discovery.expects(:new).returns(@discoverer)
+
+      Config.instance.instance_variable_set("@configured", true)
+      PluginManager.expects("[]").with("connector_plugin").returns(@connector)
+      PluginManager.expects("[]").with("security_plugin").returns(@security)
+
+      @client = Client.new("/nonexisting")
+      @client.options = Util.default_options
+    end
+
+    describe "#sendreq" do
+      it "should send the supplied message" do
+        message = Message.new("rspec", nil, {:agent => "rspec", :type => :request, :collective => "mcollective", :filter => Util.empty_filter, :options => Util.default_options})
+
+        message.expects(:encode!)
+        @client.expects(:subscribe).with("rspec", :reply)
+        message.expects(:publish)
+        message.expects(:requestid).twice
+        @client.sendreq(message, "rspec")
+      end
+
+      it "should not subscribe to a reply queue for a message with a reply-to" do
+        message = Message.new("rspec", nil, {:agent => "rspec", :type => :request, :collective => "mcollective", :filter => Util.empty_filter, :options => Util.default_options})
+        message.reply_to = "rspec"
+
+        message.expects(:encode!)
+        @client.expects(:subscribe).never
+        message.expects(:publish)
+        message.expects(:requestid).twice
+        @client.sendreq(message, "rspec")
+      end
+    end
+    describe "#req" do
+      it "should record the requestid" do
+        message = Message.new("rspec", nil, {:agent => "rspec", :type => :request, :collective => "mcollective", :filter => Util.empty_filter, :options => Util.default_options})
+        message.discovered_hosts = ["rspec"]
+
+        reply = mock
+        reply.stubs("payload").returns("rspec payload")
+
+        @client.expects(:sendreq).returns("823a3419a0975c3facbde121f72ab61f")
+        @client.expects(:receive).returns(reply)
+
+        @discoverer.stubs(:discovery_timeout).returns(0)
+
+        Time.stubs(:now).returns(Time.at(1340621250), Time.at(1340621251))
+
+        @client.req(message){}.should == {:blocktime => 1.0, :discoverytime => 0, :noresponsefrom => [],
+                                          :requestid => "823a3419a0975c3facbde121f72ab61f", :responses => 1,
+                                          :starttime => 1340621250.0, :totaltime => 1.0}
+      end
+    end
+
+    describe "#discover" do
+      it "should delegate to the discovery plugins" do
+        @discoverer.expects(:discover).with({}, 1, 0).returns([])
+        @client.discover({}, 1).should == []
+      end
+    end
+  end
+end

data/spec/unit/config_spec.rb

@@ -75,73 +75,71 @@ module MCollective
         Config.instance.loadconfig("/nonexisting")
         Config.instance.rpchelptemplate.should == "/etc/mcollective/rpc-help.erb"
       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(: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
     end
 
     describe "#read_plugin_config_dir" do
       before do
-        tmpfile = Tempfile.new("mc_config_spec")
-        path = tmpfile.path
-        tmpfile.close!
-
-        @tmpdir = FileUtils.mkdir_p(path)
-        @tmpdir = @tmpdir[0] if @tmpdir.is_a?(Array) # ruby 1.9.2
+        @plugindir = File.join("/", "nonexisting", "plugin.d")
 
-        @plugindir = File.join([@tmpdir, "plugin.d"])
-        FileUtils.mkdir(@plugindir)
+        File.stubs(:directory?).with(@plugindir).returns(true)
 
         Config.instance.set_config_defaults("")
       end
 
       it "should not fail if the supplied directory is missing" do
-        Config.instance.read_plugin_config_dir("/nonexisting")
+        File.expects(:directory?).with(@plugindir).returns(false)
+        Config.instance.read_plugin_config_dir(@plugindir)
         Config.instance.pluginconf.should == {}
       end
 
       it "should skip files that do not match the expected filename pattern" do
-        File.open(File.join([@tmpdir, "plugin.d", "foo.txt"]), "w") { }
-        IO.expects(:open).with(File.join([@tmpdir, "plugin.d", "foo.txt"])).never
+        Dir.expects(:new).with(@plugindir).returns(["foo.txt"])
+
+        IO.expects(:open).with(File.join(@plugindir, "foo.txt")).never
 
         Config.instance.read_plugin_config_dir(@plugindir)
       end
 
       it "should load the config files" do
-        configfile = File.join([@tmpdir, "plugin.d", "foo.cfg"])
-        File.open(configfile, "w") { }
-
-        File.expects(:open).with(configfile, "r").returns([]).once
+        Dir.expects(:new).with(@plugindir).returns(["foo.cfg"])
+        File.expects(:open).with(File.join(@plugindir, "foo.cfg"), "r").returns([]).once
         Config.instance.read_plugin_config_dir(@plugindir)
       end
 
       it "should set config parameters correctly" do
-        configfile = File.join([@tmpdir, "plugin.d", "foo.cfg"])
-
-        File.open(configfile, "w") do |f|
-          f.puts "bar = baz"
-        end
-
-        Config.instance.set_config_defaults(@tmpdir)
+        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.bar" => "baz"}
+        Config.instance.pluginconf.should == {"foo.rspec" => "test"}
       end
 
       it "should override main config file" do
-        configfile = File.join([@tmpdir, "plugin.d", "foo.cfg"])
-        servercfg = File.join(@tmpdir, "server.cfg")
-
-        File.open(servercfg, "w") {|f| f.puts "plugin.foo.bar = foo"}
+        configfile = File.join(@plugindir, "foo.cfg")
+        servercfg = File.join(File.dirname(@plugindir), "server.cfg")
 
         PluginManager.stubs(:loadclass)
 
-        Config.instance.loadconfig(servercfg)
-        Config.instance.pluginconf.should == {"foo.bar" => "foo"}
+        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.open(configfile, "w") do |f|
-          f.puts "bar = baz"
-        end
+        Dir.expects(:new).with(@plugindir).returns(["rspec.cfg"])
+        File.expects(:open).with(File.join(@plugindir, "rspec.cfg"), "r").returns(["key = overridden"])
 
-        PluginManager.delete("global_stats")
         Config.instance.loadconfig(servercfg)
-        Config.instance.pluginconf.should == {"foo.bar" => "baz"}
+        Config.instance.pluginconf.should == {"rspec.key" => "overridden"}
       end
     end
   end

data/spec/unit/data/base_spec.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module Data
+    describe Base do
+      before do
+        @ddl = mock
+        @ddl.stubs(:meta).returns({:timeout => 1})
+      end
+
+      describe "#initialize" do
+        it "should set the plugin name, ddl and timeout and call the startup hook" do
+          DDL.stubs(:new).returns(@ddl)
+          Base.any_instance.expects(:startup_hook).once
+          plugin = Base.new
+          plugin.name.should == "base"
+          plugin.timeout.should == 1
+          plugin.result.class.should == Result
+        end
+      end
+
+      describe "#lookup" do
+        before do
+          DDL.stubs(:new).returns(@ddl)
+          @plugin = Base.new
+        end
+
+        it "should validate the request" do
+          @plugin.expects(:ddl_validate).with("hello world").returns(true)
+          @plugin.stubs(:query_data)
+          @plugin.lookup("hello world")
+        end
+
+        it "should query the plugin" do
+          @plugin.stubs(:ddl_validate)
+          @plugin.expects(:query_data).with("hello world")
+          @plugin.lookup("hello world").class.should == Result
+        end
+
+        it "should raise MsgTTLExpired errors for Timeout errors" do
+          @plugin.stubs(:ddl_validate)
+          @plugin.expects(:query_data).raises(Timeout::Error)
+
+          msg = "Data plugin base timed out on query 'hello world'"
+          Log.expects(:error).with(msg)
+          expect { @plugin.lookup("hello world") }.to raise_error(msg)
+        end
+      end
+
+      describe "#query" do
+        it "should create a new method" do
+          class Rspec_data<Base; end
+          Rspec_data.query { "rspec test" }
+
+          DDL.stubs(:new).returns(@ddl)
+
+          data = Rspec_data.new
+          data.query_data.should == "rspec test"
+        end
+      end
+
+      describe "#ddl_validate" do
+        it "should validate the request using the Data class" do
+          DDL.stubs(:new).returns(@ddl)
+          plugin = Base.new
+          Data.expects(:ddl_validate).with(@ddl, "rspec")
+          plugin.ddl_validate("rspec")
+        end
+      end
+
+      describe "#activate_when" do
+        it "should create a new activate? method" do
+          class Rspec_data<Base;end
+
+          Rspec_data.activate_when { raise "rspec" }
+          DDL.stubs(:new).returns(@ddl)
+          expect { Rspec_data.activate? }.to raise_error("rspec")
+        end
+      end
+
+      describe "#activate?" do
+        it "should default to true" do
+          Base.activate?.should == true
+        end
+      end
+    end
+  end
+end

data/spec/unit/data/result_spec.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module Data
+    describe Result do
+      before(:each) do
+        @result = Result.new
+      end
+
+      describe "#[]=" do
+        it "should only allow trusted types of data to be saved" do
+          expect { @result["rspec"] = Time.now }.to raise_error
+          @result["rspec"] = 1
+          @result["rspec"] = 1.1
+          @result["rspec"] = "rspec"
+          @result["rspec"] = true
+          @result["rspec"] = false
+        end
+
+        it "should set the correct value" do
+          @result["rspec"] = "rspec value"
+          @result.instance_variable_get("@data").should == {:rspec => "rspec value"}
+        end
+      end
+
+      describe "#include" do
+        it "should return the correct list of keys" do
+          @result["x"] = "1"
+          @result[:y] = "2"
+          @result.keys.sort.should == [:x, :y]
+        end
+      end
+
+      describe "#include?" do
+        it "should correctly report that a key is present or absent" do
+          @result.include?("rspec").should == false
+          @result.include?(:rspec).should == false
+          @result["rspec"] = "rspec"
+          @result.include?("rspec").should == true
+          @result.include?(:rspec).should == true
+        end
+      end
+
+      describe "#[]" do
+        it "should retrieve the correct information" do
+          @result["rspec"].should == nil
+          @result[:rspec].should == nil
+          @result["rspec"] = "rspec value"
+          @result["rspec"].should == "rspec value"
+          @result[:rspec].should == "rspec value"
+        end
+      end
+
+      describe "#method_missing" do
+        it "should retrieve the correct data" do
+          @result["rspec"] = "rspec value"
+          @result.rspec.should == "rspec value"
+        end
+      end
+    end
+  end
+end