mcollective-client 1.3.3

data/spec/unit/runnerstats_spec.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe RunnerStats do
+    before do
+      Agents.stubs(:agentlist).returns("agents")
+      Time.stubs(:now).returns(Time.at(0))
+
+      @stats = RunnerStats.new
+
+      logger = mock
+      logger.stubs(:log)
+      logger.stubs(:start)
+      Log.configure(logger)
+    end
+
+    describe "#to_hash" do
+      it "should return the correct data" do
+        @stats.to_hash.keys.sort.should == [:stats, :threads, :pid, :times, :agents].sort
+
+        @stats.to_hash[:stats].should == {:validated => 0, :unvalidated => 0, :passed => 0, :filtered => 0,
+          :starttime => 0, :total => 0, :ttlexpired => 0, :replies => 0}
+
+        @stats.to_hash[:agents].should == "agents"
+      end
+    end
+
+    [[:ttlexpired, :ttlexpired], [:passed, :passed], [:filtered, :filtered],
+     [:validated, :validated], [:received, :total], [:sent, :replies]].each do |tst|
+      describe "##{tst.first}" do
+        it "should increment #{tst.first}" do
+          @stats.send(tst.first)
+          @stats.to_hash[:stats][tst.last].should == 1
+        end
+      end
+    end
+  end
+end

data/spec/unit/security/base_spec.rb

@@ -0,0 +1,279 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module Security
+    describe Base do
+      before do
+        @config = mock("config")
+        @config.stubs(:identity).returns("test")
+        @config.stubs(:configured).returns(true)
+        @config.stubs(:topicsep).returns(".")
+        @config.stubs(:topicprefix).returns("/topic/")
+
+        @stats = mock("stats")
+
+        @time = Time.now
+        ::Time.stubs(:now).returns(@time)
+
+        MCollective::Log.stubs(:debug).returns(true)
+
+        MCollective::PluginManager << {:type => "global_stats", :class => @stats}
+        MCollective::Config.stubs("instance").returns(@config)
+        MCollective::Util.stubs("empty_filter?").returns(false)
+
+        @plugin = Base.new
+      end
+
+      describe "#should_process_msg?" do
+        it "should correctly validate messages" do
+          m = mock
+          m.stubs(:expected_msgid).returns("rspec")
+
+          @plugin.should_process_msg?(m, "rspec").should == true
+
+          expect {
+            @plugin.should_process_msg?(m, "fail").should == true
+          }.to raise_error MsgDoesNotMatchRequestID
+        end
+
+        it "should not test messages without expected_msgid" do
+          m = mock
+          m.stubs(:expected_msgid).returns(nil)
+
+          @plugin.should_process_msg?(m, "rspec").should == true
+        end
+      end
+
+      describe "#validate_filter?" do
+        it "should pass on empty filter" do
+          MCollective::Util.stubs("empty_filter?").returns(true)
+
+          @stats.stubs(:passed).once
+          @stats.stubs(:filtered).never
+          @stats.stubs(:passed).never
+
+          MCollective::Log.expects(:debug).with("Message passed the filter checks").once
+
+          @plugin.validate_filter?({}).should == true
+        end
+
+        it "should pass for known classes" do
+          MCollective::Util.stubs("has_cf_class?").with("foo").returns(true)
+
+          @stats.stubs(:passed).once
+          @stats.stubs(:filtered).never
+
+          MCollective::Log.expects(:debug).with("Message passed the filter checks").once
+          MCollective::Log.expects(:debug).with("Passing based on configuration management class foo").once
+
+          @plugin.validate_filter?({"cf_class" => ["foo"]}).should == true
+        end
+
+        it "should fail for unknown classes" do
+          MCollective::Util.stubs("has_cf_class?").with("foo").returns(false)
+
+          @stats.stubs(:filtered).once
+          @stats.stubs(:passed).never
+
+          MCollective::Log.expects(:debug).with("Message failed the filter checks").once
+          MCollective::Log.expects(:debug).with("Failing based on configuration management class foo").once
+
+          @plugin.validate_filter?({"cf_class" => ["foo"]}).should == false
+        end
+
+        it "should pass for known agents" do
+          MCollective::Util.stubs("has_agent?").with("foo").returns(true)
+
+          @stats.stubs(:passed).once
+          @stats.stubs(:filtered).never
+
+          MCollective::Log.expects(:debug).with("Message passed the filter checks").once
+          MCollective::Log.expects(:debug).with("Passing based on agent foo").once
+
+          @plugin.validate_filter?({"agent" => ["foo"]}).should == true
+        end
+
+        it "should fail for unknown agents" do
+          MCollective::Util.stubs("has_agent?").with("foo").returns(false)
+
+          @stats.stubs(:filtered).once
+          @stats.stubs(:passed).never
+
+          MCollective::Log.expects(:debug).with("Message failed the filter checks").once
+          MCollective::Log.expects(:debug).with("Failing based on agent foo").once
+
+          @plugin.validate_filter?({"agent" => ["foo"]}).should == false
+        end
+
+        it "should pass for known facts" do
+          MCollective::Util.stubs("has_fact?").with("fact", "value", "operator").returns(true)
+
+          @stats.stubs(:passed).once
+          @stats.stubs(:filtered).never
+
+          MCollective::Log.expects(:debug).with("Message passed the filter checks").once
+          MCollective::Log.expects(:debug).with("Passing based on fact fact operator value").once
+
+          @plugin.validate_filter?({"fact" => [{:fact => "fact", :operator => "operator", :value => "value"}]}).should == true
+        end
+
+        it "should fail for unknown facts" do
+          MCollective::Util.stubs("has_fact?").with("fact", "value", "operator").returns(false)
+
+          @stats.stubs(:filtered).once
+          @stats.stubs(:passed).never
+
+          MCollective::Log.expects(:debug).with("Message failed the filter checks").once
+          MCollective::Log.expects(:debug).with("Failing based on fact fact operator value").once
+
+          @plugin.validate_filter?({"fact" => [{:fact => "fact", :operator => "operator", :value => "value"}]}).should == false
+        end
+
+        it "should pass for known identity" do
+          MCollective::Util.stubs("has_identity?").with("test").returns(true)
+
+          @stats.stubs(:passed).once
+          @stats.stubs(:filtered).never
+
+          MCollective::Log.expects(:debug).with("Message passed the filter checks").once
+          MCollective::Log.expects(:debug).with("Passing based on identity").once
+
+          @plugin.validate_filter?({"identity" => ["test"]}).should == true
+        end
+
+        it "should fail for known identity" do
+          MCollective::Util.stubs("has_identity?").with("test").returns(false)
+
+          @stats.stubs(:passed).never
+          @stats.stubs(:filtered).once
+
+          MCollective::Log.expects(:debug).with("Message failed the filter checks").once
+          MCollective::Log.expects(:debug).with("Failed based on identity").once
+
+          @plugin.validate_filter?({"identity" => ["test"]}).should == false
+        end
+
+        it "should treat multiple identity filters correctly" do
+          MCollective::Util.stubs("has_identity?").with("foo").returns(false)
+          MCollective::Util.stubs("has_identity?").with("bar").returns(true)
+
+          @stats.stubs(:passed).once
+          @stats.stubs(:filtered).never
+
+          MCollective::Log.expects(:debug).with("Message passed the filter checks").once
+          MCollective::Log.expects(:debug).with("Passing based on identity").once
+
+          @plugin.validate_filter?({"identity" => ["foo", "bar"]}).should == true
+        end
+
+        it "should fail if no identity matches are found" do
+          MCollective::Util.stubs("has_identity?").with("foo").returns(false)
+          MCollective::Util.stubs("has_identity?").with("bar").returns(false)
+
+          @stats.stubs(:passed).never
+          @stats.stubs(:filtered).once
+
+          MCollective::Log.expects(:debug).with("Message failed the filter checks").once
+          MCollective::Log.expects(:debug).with("Failed based on identity").once
+
+          @plugin.validate_filter?({"identity" => ["foo", "bar"]}).should == false
+        end
+      end
+
+      describe "#create_reply" do
+        it "should return correct data" do
+          expected = {:senderid => "test",
+            :requestid => "reqid",
+            :senderagent => "agent",
+            :msgtime => @time.to_i,
+            :body => "body"}
+
+          @plugin.create_reply("reqid", "agent", "body").should == expected
+        end
+      end
+
+      describe "#create_request" do
+        it "should return correct data" do
+          expected = {:body => "body",
+            :senderid => "test",
+            :requestid => "reqid",
+            :callerid => "uid=#{Process.uid}",
+            :agent => "discovery",
+            :collective => "mcollective",
+            :filter => "filter",
+            :ttl => 20,
+            :msgtime => @time.to_i}
+
+          @plugin.create_request("reqid", "filter", "body", :server, "discovery", "mcollective", 20).should == expected
+        end
+
+        it "should set the callerid when appropriate" do
+          expected = {:body => "body",
+            :senderid => "test",
+            :requestid => "reqid",
+            :agent => "discovery",
+            :collective => "mcollective",
+            :filter => "filter",
+            :callerid => "callerid",
+            :ttl => 60,
+            :msgtime => @time.to_i}
+
+          @plugin.stubs(:callerid).returns("callerid")
+          @plugin.create_request("reqid", "filter", "body", :client, "discovery", "mcollective").should == expected
+        end
+      end
+
+      describe "#valid_callerid?" do
+        it "should not pass invalid callerids" do
+          @plugin.valid_callerid?("foo-bar").should == false
+          @plugin.valid_callerid?("foo=bar=baz").should == false
+          @plugin.valid_callerid?('foo=bar\baz').should == false
+          @plugin.valid_callerid?("foo=bar/baz").should == false
+          @plugin.valid_callerid?("foo=bar|baz").should == false
+        end
+
+        it "should pass valid callerids" do
+          @plugin.valid_callerid?("cert=foo-bar").should == true
+          @plugin.valid_callerid?("uid=foo.bar").should == true
+          @plugin.valid_callerid?("uid=foo.bar.123").should == true
+        end
+      end
+
+      describe "#callerid" do
+        it "should return a unix UID based callerid" do
+          @plugin.callerid.should == "uid=#{Process.uid}"
+        end
+      end
+
+      describe "#validrequest?" do
+        it "should log an error when not implimented" do
+          MCollective::Log.expects(:error).with("validrequest? is not implimented in MCollective::Security::Base")
+          @plugin.validrequest?(nil)
+        end
+      end
+
+      describe "#encoderequest" do
+        it "should log an error when not implimented" do
+          MCollective::Log.expects(:error).with("encoderequest is not implimented in MCollective::Security::Base")
+          @plugin.encoderequest(nil, nil, nil)
+        end
+      end
+
+      describe "#encodereply" do
+        it "should log an error when not implimented" do
+          MCollective::Log.expects(:error).with("encodereply is not implimented in MCollective::Security::Base")
+          @plugin.encodereply(nil, nil, nil)
+        end
+      end
+
+      describe "#decodemsg" do
+        it "should log an error when not implimented" do
+          MCollective::Log.expects(:error).with("decodemsg is not implimented in MCollective::Security::Base")
+          @plugin.decodemsg(nil)
+        end
+      end
+    end
+  end
+end

data/spec/unit/shell_spec.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Shell do
+    describe "#initialize" do
+      it "should set locale by default" do
+        s = Shell.new("date")
+        s.environment.should == {"LC_ALL" => "C"}
+      end
+
+      it "should merge environment and keep locale" do
+        s = Shell.new("date", :environment => {"foo" => "bar"})
+        s.environment.should == {"LC_ALL" => "C", "foo" => "bar"}
+      end
+
+      it "should allow locale to be overridden" do
+        s = Shell.new("date", :environment => {"LC_ALL" => "TEST", "foo" => "bar"})
+        s.environment.should == {"LC_ALL" => "TEST", "foo" => "bar"}
+      end
+
+      it "should set no environment when given nil" do
+        s = Shell.new("date", :environment => nil)
+        s.environment.should == {}
+      end
+
+      it "should save the command" do
+        s = Shell.new("date")
+        s.command.should == "date"
+      end
+
+      it "should check the cwd exist" do
+        expect {
+          s = Shell.new("date", :cwd => "/nonexistant")
+        }.to raise_error("Directory /nonexistant does not exist")
+      end
+
+      it "should warn of illegal stdin" do
+        expect {
+          s = Shell.new("date", :stdin => nil)
+        }.to raise_error("stdin should be a String")
+      end
+
+      it "should warn of illegal stdout" do
+        expect {
+          s = Shell.new("date", :stdout => nil)
+        }.to raise_error("stdout should support <<")
+      end
+
+      it "should warn of illegal stderr" do
+        expect {
+          s = Shell.new("date", :stderr => nil)
+        }.to raise_error("stderr should support <<")
+      end
+
+      it "should set stdout" do
+        s = Shell.new("date", :stdout => "stdout")
+        s.stdout.should == "stdout"
+      end
+
+      it "should set stderr" do
+        s = Shell.new("date", :stderr => "stderr")
+        s.stderr.should == "stderr"
+      end
+
+      it "should set stdin" do
+        s = Shell.new("date", :stdin => "hello world")
+        s.stdin.should == "hello world"
+      end
+    end
+
+    describe "#runcommand" do
+      it "should run the command" do
+        Shell.any_instance.stubs("systemu").returns(true).once.with("date", "stdout" => '', "stderr" => '', "env" => {"LC_ALL" => "C"}, 'cwd' => Dir.tmpdir)
+        s = Shell.new("date")
+        s.runcommand
+      end
+
+      it "should set stdin, stdout and status" do
+        s = Shell.new('ruby -e "STDERR.puts \"stderr\"; STDOUT.puts \"stdout\""')
+        s.runcommand
+        s.stdout.should == "stdout\n"
+        s.stderr.should == "stderr\n"
+        s.status.exitstatus.should == 0
+      end
+
+      it "should report correct exitcode" do
+        s = Shell.new('ruby -e "exit 1"')
+        s.runcommand
+
+        s.status.exitstatus.should == 1
+      end
+
+      it "shold have correct environment" do
+        s = Shell.new('ruby -e "puts ENV[\'LC_ALL\'];puts ENV[\'foo\'];"', :environment => {"foo" => "bar"})
+        s.runcommand
+        s.stdout.should == "C\nbar\n"
+      end
+
+      it "should save stdout in custom stdout variable" do
+        out = "STDOUT"
+
+        s = Shell.new('echo foo', :stdout => out)
+        s.runcommand
+
+        s.stdout.should == "STDOUTfoo\n"
+        out.should == "STDOUTfoo\n"
+      end
+
+      it "should save stderr in custom stderr variable" do
+        out = "STDERR"
+
+        s = Shell.new('ruby -e "STDERR.puts \"foo\""', :stderr => out)
+        s.runcommand
+
+        s.stderr.should == "STDERRfoo\n"
+        out.should == "STDERRfoo\n"
+      end
+
+      it "should run in the correct cwd" do
+        s = Shell.new('ruby -e "puts Dir.pwd"', :cwd => Dir.tmpdir)
+
+        s.runcommand
+
+        s.stdout.should == "#{Dir.tmpdir}\n"
+      end
+
+      it "should send the stdin" do
+        s = Shell.new('ruby -e "puts STDIN.gets"', :stdin => "hello world")
+        s.runcommand
+
+        s.stdout.should == "hello world\n"
+      end
+
+      it "should support multiple lines of stdin" do
+        s = Shell.new('ruby -e "puts STDIN.gets;puts;puts STDIN.gets"', :stdin => "first line\n2nd line")
+        s.runcommand
+
+        s.stdout.should == "first line\n\n2nd line\n"
+      end
+    end
+  end
+end