mcollective-client 1.3.3

data/spec/unit/applications_spec.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Applications do
+    before do
+      tmpfile = Tempfile.new("mc_applications_spec")
+      path = tmpfile.path
+      tmpfile.close!
+
+      @tmpdir = FileUtils.mkdir_p(path)
+      @tmpdir = @tmpdir[0] if @tmpdir.is_a?(Array) # ruby 1.9.2
+      $LOAD_PATH << @tmpdir
+
+      @appsdir = File.join([@tmpdir, "mcollective", "application"])
+      FileUtils.mkdir_p(@appsdir)
+
+      FileUtils.cp(File.join([File.dirname(__FILE__), "..", "fixtures", "application", "test.rb"]), @appsdir)
+    end
+
+    after do
+      FileUtils.rm_r(@tmpdir)
+    end
+
+    describe "[]" do
+      it "should load the config" do
+        Applications.expects(:load_config).once
+        PluginManager.expects("[]").once
+        Applications["test"]
+      end
+
+      it "should return the correct stored application" do
+        app = mock("app")
+        app.stubs(:run)
+
+        Applications.expects(:load_config).once
+        PluginManager.expects("[]").with("test_application").once.returns(app)
+        Applications["test"].should == app
+      end
+    end
+
+    describe "#run" do
+      it "should load the configuration" do
+        app = mock("app")
+        app.stubs(:run)
+
+        Applications.expects(:load_config).once
+        Applications.expects(:load_application).once
+        PluginManager.expects("[]").once.returns(app)
+
+        Applications.run("test")
+      end
+
+      it "should load the application" do
+        app = mock("app")
+        app.stubs(:run)
+
+        Applications.expects(:load_config).once
+        Applications.expects(:load_application).with("test").once
+        PluginManager.expects("[]").once.returns(app)
+
+        Applications.run("test")
+      end
+
+      it "should invoke the application run method" do
+        app = mock("app")
+        app.stubs(:run).returns("hello world")
+
+        Applications.expects(:load_config).once
+        Applications.expects(:load_application)
+        PluginManager.expects("[]").once.returns(app)
+
+        Applications.run("test").should == "hello world"
+      end
+    end
+
+    describe "#load_application" do
+      it "should return the existing application if already loaded" do
+        app = mock("app")
+        app.stubs(:run)
+
+        PluginManager << {:type => "test_application", :class => app}
+
+        Applications.expects("load_config").never
+
+        Applications.load_application("test")
+      end
+
+      it "should load the config" do
+        Applications.expects("load_config").returns(true).once
+        Applications.load_application("test")
+      end
+
+      it "should load the correct class from disk" do
+        PluginManager.expects("loadclass").with("MCollective::Application::Test")
+        Applications.expects("load_config").returns(true).once
+
+        Applications.load_application("test")
+      end
+
+      it "should add the class to the plugin manager" do
+        Applications.expects("load_config").returns(true).once
+
+        PluginManager.expects("<<").with({:type => "test_application", :class => "MCollective::Application::Test"})
+
+        Applications.load_application("test")
+      end
+    end
+
+    describe "#list" do
+      it "should load the configuration" do
+        Applications.expects("load_config").returns(true).once
+        Config.any_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])
+
+        Applications.list.should == ["test"]
+      end
+
+      it "should print a friendly error and exit on failure" do
+        Applications.expects("load_config").raises(Exception)
+        IO.any_instance.expects(:puts).with(regexp_matches(/Failed to generate application list/)).once
+
+        expect {
+          Applications.list.should
+        }.to raise_error(SystemExit)
+      end
+    end
+
+    describe "#filter_extra_options" do
+      it "should parse --config=x" do
+        ["--config=x --foo=bar -f -f bar", "--foo=bar --config=x -f -f bar"].each do |t|
+          Applications.filter_extra_options(t).should == "--config=x"
+        end
+      end
+
+      it "should parse --config x" do
+        ["--config x --foo=bar -f -f bar", "--foo=bar --config x -f -f bar"].each do |t|
+          Applications.filter_extra_options(t).should == "--config=x"
+        end
+      end
+
+      it "should parse -c x" do
+        ["-c x --foo=bar -f -f bar", "--foo=bar -c x -f -f bar"].each do |t|
+          Applications.filter_extra_options(t).should == "--config=x"
+        end
+      end
+    end
+  end
+end

data/spec/unit/array.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+class Array
+  describe "#in_groups_of" do
+    it "should correctly group array members" do
+      [1,2,3,4,5,6,7,8,9,10].in_groups_of(5).should == [[1,2,3,4,5], [6,7,8,9,10]]
+    end
+
+    it "should padd missing data with correctly" do
+      arr = [1,2,3,4,5,6,7,8,9,10]
+
+      arr.in_groups_of(3).should == [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, nil, nil]]
+      arr.in_groups_of(3, 0).should == [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 0, 0]]
+      arr.in_groups_of(11).should == [[1,2,3,4,5, 6,7,8,9,10, nil]]
+      arr.in_groups_of(11, 0).should == [[1,2,3,4,5, 6,7,8,9,10, 0]]
+    end
+
+    it "should indicate when the last abtched was reached" do
+      arr = [1,2,3,4,5,6,7,8,9,10]
+
+      ctr = 0
+
+      [1,2,3,4,5,6,7,8,9,10].in_groups_of(3) {|a, last_batch| ctr += 1 unless last_batch}
+
+      ctr.should == 3
+    end
+  end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Config do
+    describe "#loadconfig" do
+      it "should not allow any path like construct for identities" do
+        # Taken from puppet test cases
+        ['../foo', '..\\foo', './../foo', '.\\..\\foo',
+          '/foo', '//foo', '\\foo', '\\\\goo',
+          "test\0/../bar", "test\0\\..\\bar",
+          "..\\/bar", "/tmp/bar", "/tmp\\bar", "tmp\\bar",
+          " / bar", " /../ bar", " \\..\\ bar",
+          "c:\\foo", "c:/foo", "\\\\?\\UNC\\bar", "\\\\foo\\bar",
+          "\\\\?\\c:\\foo", "//?/UNC/bar", "//foo/bar",
+          "//?/c:/foo"
+        ].each do |input|
+          File.expects(:open).with("/nonexisting", "r").returns(StringIO.new("identity = #{input}"))
+          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")
+          }.to raise_error('Identities can only match /\w\.\-/')
+        end
+      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(: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")
+        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"))
+        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")
+      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(""))
+        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
+      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(""))
+        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"
+      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([@tmpdir, "plugin.d"])
+        FileUtils.mkdir(@plugindir)
+
+        Config.instance.set_config_defaults("")
+      end
+
+      it "should not fail if the supplied directory is missing" do
+        Config.instance.read_plugin_config_dir("/nonexisting")
+        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
+
+        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
+        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)
+        Config.instance.read_plugin_config_dir(@plugindir)
+        Config.instance.pluginconf.should == {"foo.bar" => "baz"}
+      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"}
+
+        PluginManager.stubs(:loadclass)
+
+        Config.instance.loadconfig(servercfg)
+        Config.instance.pluginconf.should == {"foo.bar" => "foo"}
+
+        File.open(configfile, "w") do |f|
+          f.puts "bar = baz"
+        end
+
+        PluginManager.delete("global_stats")
+        Config.instance.loadconfig(servercfg)
+        Config.instance.pluginconf.should == {"foo.bar" => "baz"}
+      end
+    end
+  end
+end

data/spec/unit/facts/base_spec.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective::Facts
+  describe Base do
+    before do
+      class Testfacts<Base; end
+
+      MCollective::PluginManager.delete("facts_plugin")
+      MCollective::PluginManager << {:type => "facts_plugin", :class => "MCollective::Facts::Testfacts"}
+    end
+
+    describe "#inherited" do
+      it "should add classes to the plugin manager" do
+        MCollective::PluginManager.stubs("<<").with({:type => "facts_plugin", :class => "MCollective::Facts::Bar"})
+
+        class Bar<Base; end
+      end
+
+      it "should be available in the PluginManager" do
+        MCollective::PluginManager["facts_plugin"].class.should == MCollective::Facts::Testfacts
+      end
+    end
+
+    describe "#get_fact" do
+      it "should call the fact provider #load_facts_from_source" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar"}).once
+
+        f = Testfacts.new
+        f.get_fact("foo")
+      end
+
+      it "should honor the cache timeout" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar"}).once
+
+        f = Testfacts.new
+        f.get_fact("foo")
+        f.get_fact("foo")
+      end
+
+      it "should detect empty facts" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({})
+        MCollective::Log.expects("error").with("Failed to load facts: RuntimeError: Got empty facts").once
+
+        f = Testfacts.new
+        f.get_fact("foo")
+      end
+
+      it "should convert non string facts to strings" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({:foo => "bar"})
+
+        f = Testfacts.new
+        f.get_fact("foo").should == "bar"
+      end
+
+      it "should not create duplicate facts while converting to strings" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({:foo => "bar"})
+
+        f = Testfacts.new
+        f.get_fact(nil).include?(:foo).should == false
+      end
+
+      it "should update last_facts_load on success" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar"}).once
+
+        f = Testfacts.new
+        f.get_fact("foo")
+
+        f.instance_variable_get("@last_facts_load").should_not == 0
+      end
+
+      it "should restore last known good facts on failure" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({}).once
+        MCollective::Log.expects("error").with("Failed to load facts: RuntimeError: Got empty facts").once
+
+        f = Testfacts.new
+        f.instance_variable_set("@last_good_facts", {"foo" => "bar"})
+
+        f.get_fact("foo").should == "bar"
+      end
+
+      it "should return all facts for nil parameter" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar", "bar" => "baz"})
+
+        f = Testfacts.new
+        f.get_fact(nil).keys.size.should == 2
+      end
+
+      it "should return a specific fact when specified" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar", "bar" => "baz"})
+
+        f = Testfacts.new
+        f.get_fact("bar").should == "baz"
+      end
+    end
+
+    describe "#get_facts" do
+      it "should load and return all facts" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar", "bar" => "baz"})
+
+        f = Testfacts.new
+        f.get_facts.should == {"foo" => "bar", "bar" => "baz"}
+      end
+    end
+
+    describe "#has_fact?" do
+      it "should correctly report fact presense" do
+        Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar"})
+
+        f = Testfacts.new
+        f.has_fact?("foo").should == true
+        f.has_fact?("bar").should == false
+      end
+    end
+
+  end
+end