mcollective-client 1.3.3

data/spec/unit/plugins/mcollective/packagers/ospackage_spec.rb

@@ -0,0 +1,229 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+MCollective::PluginManager.clear
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/pluginpackager/ospackage_packager.rb'
+
+module MCollective
+  module PluginPackager
+    describe OspackagePackager do
+      before :all do
+
+        class OspackagePackager
+          ENV = {"PATH" => "."}
+        end
+
+        class TestPlugin
+          attr_accessor :path, :packagedata, :metadata, :target_path, :vendor, :iteration
+          attr_accessor :postinstall
+
+          def initialize
+            @path = "/tmp"
+            @packagedata = {:testpackage => {:files => ["/tmp/test.rb"],
+                                             :dependencies => ["mcollective"],
+                                             :description => "testpackage"}}
+            @iteration = 1
+            @postinstall = "/tmp/test.sh"
+            @metadata = {:name => "testplugin",
+                         :description => "A Test Plugin",
+                         :author => "Psy",
+                         :license => "Apache 2",
+                         :version => "0",
+                         :url => "http://foo.bar.com",
+                         :timeout => 5}
+            @vendor = "Puppet Labs"
+            @target_path = "/tmp"
+          end
+        end
+
+        @testplugin = TestPlugin.new
+      end
+
+      describe "#initialize" do
+        it "should correctly identify a RedHat system" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(true)
+          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
+
+          ospackage = OspackagePackager.new(@testplugin)
+          ospackage.libdir.should == "usr/libexec/mcollective/mcollective/"
+          ospackage.package_type.should == "RPM"
+        end
+
+        it "should correctly identify a Debian System" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(false)
+          File.expects(:exists?).with("/etc/debian_version").returns(true)
+          OspackagePackager.any_instance.expects(:build_tool?).with("ar").returns(true)
+
+          ospackage = OspackagePackager.new(@testplugin)
+          ospackage.libdir.should == "usr/share/mcollective/plugins/mcollective"
+          ospackage.package_type.should == "Deb"
+        end
+
+        it "should raise an exception if it cannot identify the operating system" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(false)
+          File.expects(:exists?).with("/etc/debian_version").returns(false)
+
+          expect{
+            ospackage = OspackagePackager.new(@testplugin)
+          }.to raise_exception "error: cannot identify operating system."
+        end
+
+        it "should identify if rpmbuild is present for RedHat systems" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(true)
+          File.expects(:exists?).with("./rpmbuild").returns(true)
+          ospackage = OspackagePackager.new(@testplugin)
+        end
+
+        it "should raise an exception if rpmbuild is not present for RedHat systems" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(true)
+          File.expects(:exists?).with("./rpmbuild").returns(false)
+          expect{
+            ospackage = OspackagePackager.new(@testplugin)
+          }.to raise_error "error: package 'rpm-build' is not installed."
+        end
+
+        it "should identify if ar is present for Debian systems" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(false)
+          File.expects(:exists?).with("/etc/debian_version").returns(true)
+          File.expects(:exists?).with("./ar").returns(true)
+
+          ospackage = OspackagePackager.new(@testplugin)
+        end
+
+        it "should raise an exception if the build tool is not present" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(false)
+          File.expects(:exists?).with("/etc/debian_version").returns(true)
+          File.expects(:exists?).with("./ar").returns(false)
+          expect{
+            ospackage = OspackagePackager.new(@testplugin)
+          }.to raise_error "error: package 'ar' is not installed."
+        end
+      end
+
+      describe "#create_packages" do
+        it "should prepare temp directories, create a package and clean up when done" do
+          OspackagePackager.any_instance.stubs(:gem).with("fpm", "= 0.4.3")
+          OspackagePackager.any_instance.stubs(:require).with("fpm")
+          OspackagePackager.any_instance.stubs(:require).with("tmpdir")
+
+          File.expects(:exists?).with("/etc/redhat-release").returns(true)
+          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
+          Dir.expects(:mktmpdir).with("mcollective_packager").returns("/tmp/mcollective_packager")
+          FileUtils.expects(:mkdir_p).with("/tmp/mcollective_packager/usr/libexec/mcollective/mcollective/")
+
+          ospackage = OspackagePackager.new(@testplugin)
+          ospackage.expects(:prepare_tmpdirs).once
+          ospackage.expects(:create_package).once
+          ospackage.expects(:cleanup_tmpdirs).once
+
+          ospackage.create_packages
+        end
+      end
+
+      describe "#create_package" do
+        before :all do
+          module ::FPM
+            class Package
+              class Dir
+              end
+              class RPM
+              end
+            end
+          end
+
+          @fpm_dir = mock
+          @fpm_type = mock
+          @package = mock
+          @fpm_dir.stubs(:convert).returns(@fpm_type)
+          @fpm_dir.stubs(:attributes).returns({:chdir => nil})
+          @fpm_dir.stubs(:input)
+          @package.stubs(:metadata).returns({:name => "testpackage", :version => "1"})
+          @package.stubs(:iteration).returns("1")
+          OspackagePackager.any_instance.stubs(:package).returns(@package)
+        end
+
+        it "should run fpm with the correct parameters" do
+          File.stubs(:exists?).returns(true)
+          OspackagePackager.any_instance.expects(:build_tool?).returns(true)
+          ospackage = OspackagePackager.new(@testpackage)
+          ::FPM::Package::Dir.stubs(:new).returns(@fpm_dir)
+          ospackage.expects(:params)
+          ospackage.expects(:do_quietly?)
+          @fpm_dir.expects(:cleanup)
+          @fpm_type.expects(:cleanup)
+          ospackage.expects(:puts).with("Successfully built RPM 'mcollective-testpackage-testpackage-1-1.noarch.rpm'")
+          ospackage.create_package(:testpackage, {:files => ["/tmp/test.rb"], :description => "testpackage", :dependencies =>"dependencies"})
+        end
+      end
+
+      describe "#do_quietly?" do
+        it "should run a block quietly" do
+          require 'stringio'
+
+          File.expects(:exists?).with("/etc/redhat-release").returns(true)
+          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
+          ospackage = OspackagePackager.new(@testplugin)
+
+          old_stdout = $stdout
+          new_stdout = File.open("/tmp/output.txt", "w+")
+          $stdout = new_stdout
+          ospackage.do_quietly?{puts "teststring"}
+          $stdout = old_stdout
+          File.read("/tmp/output.txt").should == ""
+          FileUtils.rm("/tmp/output.txt")
+        end
+      end
+
+      describe "#params" do
+        it "should create all paramaters needed by fpm" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(true)
+          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
+          ospackage = OspackagePackager.new(@testplugin)
+
+          fpm_type = mock
+          fpm_type.expects(:name=).with("mcollective-testplugin-testpackage")
+          fpm_type.expects(:maintainer=).with("Psy")
+          fpm_type.expects(:version=).with("0")
+          fpm_type.expects(:url=).with("http://foo.bar.com")
+          fpm_type.expects(:license=).with("Apache 2")
+          fpm_type.expects(:iteration=).with(1)
+          fpm_type.expects(:vendor=).with("Puppet Labs")
+          fpm_type.expects(:architecture=).with("all")
+          fpm_type.expects(:description=).with("A Test Plugin\n\ntestpackage")
+          fpm_type.expects(:dependencies=).with(["mcollective"])
+          fpm_type.expects(:scripts).returns({"post-install" => nil})
+
+          ospackage.params(fpm_type,:testpackage, @testplugin.packagedata[:testpackage])
+
+        end
+      end
+
+      describe "#prepare_tmpdirs" do
+        it "should create temp directories and copy package files" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(true)
+          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
+          File.expects(:directory?).with("/tmp/mcollective_packager/").returns(false)
+          FileUtils.expects(:mkdir_p).with("/tmp/mcollective_packager/")
+          FileUtils.expects(:cp_r).with("/tmp/test.rb", "/tmp/mcollective_packager/")
+
+          ospackage = OspackagePackager.new(@testplugin)
+          ospackage.workingdir = "/tmp/mcollective_packager/"
+          ospackage.prepare_tmpdirs(@testplugin.packagedata[:testpackage])
+        end
+      end
+
+      describe "#cleanup_tmpdirs" do
+        it "should remove temp directories" do
+          File.expects(:exists?).with("/etc/redhat-release").returns(true)
+          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
+          FileUtils.expects(:rm_r).with("/tmp/mcollective_packager/")
+
+          ospackage = OspackagePackager.new(@testplugin)
+          ospackage.tmpdir = "/tmp/mcollective_packager/"
+          ospackage.cleanup_tmpdirs
+        end
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/security/psk_spec.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/security/psk.rb'
+
+module MCollective::Security
+  describe Psk do
+    before do
+      @config = mock("config")
+      @config.stubs(:identity).returns("test")
+      @config.stubs(:configured).returns(true)
+      @config.stubs(:pluginconf).returns({"psk" => "12345"})
+
+      @stats = mock("stats")
+
+      @time = Time.now.to_i
+      ::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 = Psk.new
+    end
+
+    describe "#decodemsg" do
+      it "should correctly decode a message" do
+        @plugin.stubs("validrequest?").returns(true).once
+
+        msg = mock("message")
+        msg.stubs(:payload).returns(Marshal.dump({:body => Marshal.dump("foo")}))
+        msg.stubs(:expected_msgid).returns(nil)
+
+        @plugin.decodemsg(msg).should == {:body=>"foo"}
+      end
+
+      it "should return nil on failure" do
+        @plugin.stubs("validrequest?").raises("fail").once
+
+        msg = mock("message")
+        msg.stubs(:payload).returns(Marshal.dump({:body => Marshal.dump("foo"), :requestid => "123"}))
+        msg.stubs(:expected_msgid).returns(nil)
+
+        expect { @plugin.decodemsg(msg) }.to raise_error("fail")
+      end
+
+      it "should not decode messages not addressed to us" do
+        msg = mock("message")
+        msg.stubs(:payload).returns(Marshal.dump({:body => Marshal.dump("foo"), :requestid => "456"}))
+        msg.stubs(:expected_msgid).returns("123")
+
+        expect {
+          @plugin.decodemsg(msg)
+        }.to raise_error("Got a message with id 456 but was expecting 123, ignoring message")
+
+      end
+
+      it "should only decode messages addressed to us" do
+        @plugin.stubs("validrequest?").returns(true).once
+
+        msg = mock("message")
+        msg.stubs(:payload).returns(Marshal.dump({:body => Marshal.dump("foo"), :requestid => "456"}))
+        msg.stubs(:expected_msgid).returns("456")
+
+        @plugin.decodemsg(msg).should == {:body=>"foo", :requestid=>"456"}
+      end
+    end
+
+    describe "#encodereply" do
+      it "should correctly Marshal encode the reply" do
+        @plugin.stubs("create_reply").returns({:test => "test"})
+        Marshal.stubs("dump").with("test message").returns("marshal_test_message").once
+        Marshal.stubs("dump").with({:hash => '2dbeb0d7938a08a34eacd2c1dab25602', :test => 'test'}).returns("marshal_test_reply").once
+
+        @plugin.encodereply("sender", "test message", "requestid", "callerid").should == "marshal_test_reply"
+      end
+    end
+
+    describe "#encoderequest" do
+      it "should correctly Marshal encode the request" do
+        @plugin.stubs("create_request").returns({:test => "test"})
+        Marshal.stubs("dump").with("test message").returns("marshal_test_message").once
+        Marshal.stubs("dump").with({:hash => '2dbeb0d7938a08a34eacd2c1dab25602', :test => 'test'}).returns("marshal_test_request").once
+
+        @plugin.encoderequest("sender", "test message", "requestid", "filter", "agent", "collective").should == "marshal_test_request"
+      end
+    end
+
+    describe "#validrequest?" do
+      it "should correctly validate requests" do
+        @stats.stubs(:validated).once
+        @stats.stubs(:unvalidated).never
+        @plugin.validrequest?({:body => "foo", :hash => "e83ac78027b77b659a49bccbbcfa4849"})
+      end
+
+      it "should raise an exception on failure" do
+        @stats.stubs(:validated).never
+        @stats.stubs(:unvalidated).once
+        expect { @plugin.validrequest?({:body => "foo", :hash => ""}) }.to raise_error("Received an invalid signature in message")
+      end
+    end
+
+    describe "#callerid" do
+      it "should do uid based callerid when unconfigured" do
+        @plugin.callerid.should == "uid=#{Process.uid}"
+      end
+
+      it "should support gid based callerids" do
+        @config.stubs(:pluginconf).returns({"psk.callertype" => "gid"})
+        @plugin.callerid.should == "gid=#{Process.gid}"
+      end
+
+      it "should support group based callerids", :unless => MCollective::Util.windows? do
+        @config.stubs(:pluginconf).returns({"psk.callertype" => "group"})
+        @plugin.callerid.should == "group=#{Etc.getgrgid(Process.gid).name}"
+      end
+
+      it "should raise an error if the group callerid type is used on windows" do
+        MCollective::Util.expects("windows?").returns(true)
+        @config.stubs(:pluginconf).returns({"psk.callertype" => "group"})
+        expect { @plugin.callerid }.to raise_error("Cannot use the 'group' callertype for the PSK security plugin on the Windows platform")
+      end
+
+      it "should support user based callerids" do
+        @config.stubs(:pluginconf).returns({"psk.callertype" => "user"})
+        @plugin.callerid.should == "user=#{Etc.getlogin}"
+      end
+
+      it "should support identity based callerids" do
+        @config.stubs(:pluginconf).returns({"psk.callertype" => "identity"})
+        @plugin.callerid.should == "identity=test"
+      end
+    end
+
+    describe "#makehash" do
+      it "should return the correct md5 digest" do
+        @plugin.send(:makehash, "foo").should == "e83ac78027b77b659a49bccbbcfa4849"
+      end
+
+      it "should fail if no PSK is configured" do
+        @config.stubs(:pluginconf).returns({})
+        expect { @plugin.send(:makehash, "foo") }.to raise_error("No plugin.psk configuration option specified")
+      end
+
+      it "should support reading the PSK from the environment" do
+        ENV["MCOLLECTIVE_PSK"] = "54321"
+
+        @plugin.send(:makehash, "foo").should == "d3fb63cc6b1d47cc4b2012df926c2feb"
+
+        ENV.delete("MCOLLECTIVE_PSK")
+      end
+    end
+  end
+end

data/spec/unit/registration/base_spec.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module Registration
+    describe Base do
+      before do
+        @config = mock
+        @config.stubs(:identity).returns("rspec")
+        @config.stubs(:main_collective).returns("main_collective")
+        Config.stubs(:instance).returns(@config)
+
+        @reg = Base.new
+      end
+
+      describe "#config" do
+        it "should provide access the main configuration class" do
+          @reg.config.should == @config
+        end
+
+      end
+
+      describe "#identity" do
+        it "should return the correct identity" do
+          @reg.config.identity.should == "rspec"
+        end
+      end
+
+      describe "#msg_filter" do
+        it "should target the registration agent" do
+          @reg.msg_filter.should == {"agent" => "registration"}
+        end
+      end
+
+      describe "#target_collective" do
+        it "should return the configured registration_collective" do
+          @config.expects(:registration_collective).returns("registration").once
+          @config.expects(:collectives).returns(["main_collective", "registration"]).once
+          @reg.target_collective.should == "registration"
+        end
+
+        it "should use the main collective if registration collective is not valid" do
+          @config.expects(:registration_collective).returns("registration").once
+          @config.expects(:collectives).returns(["main_collective"]).once
+
+          Log.expects(:warn).with("Sending registration to main_collective: registration is not a valid collective").once
+
+          @reg.target_collective.should == "main_collective"
+        end
+      end
+
+      describe "#publish" do
+        it "should skip registration for empty messages" do
+          Log.expects(:debug).with("Skipping registration due to nil body")
+          @reg.publish(nil)
+        end
+
+        it "should publish via the message object" do
+          message = mock
+          message.expects(:encode!)
+          message.expects(:publish)
+          message.expects(:requestid).returns("123")
+          message.expects(:collective).returns("mcollective")
+
+          Message.expects(:new).returns(message)
+
+          Log.expects(:debug).with("Sending registration 123 to collective mcollective")
+
+          @reg.expects(:target_collective).returns("mcollective")
+
+          @reg.publish("message")
+        end
+      end
+    end
+  end
+end