mcollective-client 2.0.0 → 2.2.0

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

@@ -34,7 +34,7 @@ module MCollective
         File.expects(:exists?).with("/etc/debian_version").returns(false)
         expect{
           OspackagePackager.new("package")
-        }.to raise_error RuntimeError
+        }.to raise_error(RuntimeError)
       end
     end
 

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

@@ -16,10 +16,12 @@ module MCollective
       end
 
       before :each do
+        PluginPackager.stubs(:build_tool?).with("rpmbuild-md5").returns(true)
         PluginPackager.stubs(:build_tool?).with("rpmbuild").returns(true)
         @plugin = mock()
         @plugin.stubs(:iteration).returns("1")
         @plugin.stubs(:metadata).returns({:name => "test", :version => "1"})
+        @plugin.stubs(:mcname).returns("mcollective")
       end
 
       after :all do
@@ -28,11 +30,12 @@ module MCollective
 
       describe "#initialize" do
 
-        it "should raise and exception if rpm-build is not present" do
+        it "should raise and exception if neither rpmbuild or rpmbuild-md5 is installed is not present" do
+          PluginPackager.expects(:build_tool?).with("rpmbuild-md5").returns(false)
           PluginPackager.expects(:build_tool?).with("rpmbuild").returns(false)
           expect{
             RpmpackagePackager.new("plugin")
-          }.to raise_exception RuntimeError, "package 'rpm-build' is not installed"
+          }.to raise_exception(RuntimeError, "creating rpms require 'rpmbuild' or 'rpmbuild-md5' to be installed")
         end
 
         it "should set the correct libdir" do
@@ -81,57 +84,62 @@ module MCollective
         end
 
         it "should create the package" do
-          PluginPackager.expects(:safe_system).with("rpmbuild -bb   /tmp/SPECS/test.spec --buildroot /tmp/BUILD")
-          FileUtils.expects(:cp)
+          Dir.expects(:chdir)
+          PluginPackager.expects(:safe_system).with("rpmbuild -ta   /tmp/mcollective-testplugin-test-1.tgz")
+          FileUtils.expects(:cp).times(2)
           @packager.tmpdir = "/tmp"
           @packager.verbose = "true"
           @packager.expects(:make_spec_file)
           @packager.current_package_name = "mcollective-testplugin-test"
-          @packager.expects(:puts).with("Created package mcollective-testplugin-test")
+          @packager.expects(:puts).with('Created RPM and SRPM packages for mcollective-testplugin-test')
           @packager.create_package(:test, {:files => ["foo.rb"]})
         end
 
         it "should sign the package if a signature is given" do
-          PluginPackager.expects(:safe_system).with("rpmbuild -bb  --sign /tmp/SPECS/test.spec --buildroot /tmp/BUILD")
-          FileUtils.expects(:cp)
+          Dir.expects(:chdir)
+          PluginPackager.expects(:safe_system).with("rpmbuild -ta  --sign /tmp/mcollective-testplugin-test-1.tgz")
+          FileUtils.expects(:cp).times(2)
           @packager.signature = true
           @packager.tmpdir = "/tmp"
           @packager.verbose = "true"
           @packager.expects(:make_spec_file)
           @packager.current_package_name = "mcollective-testplugin-test"
-          @packager.expects(:puts).with("Created package mcollective-testplugin-test")
+          @packager.expects(:puts).with('Created RPM and SRPM packages for mcollective-testplugin-test')
           @packager.create_package(:test, {:files => ["foo.rb"]})
         end
 
         it "should raise an error if the package can't be built" do
           @packager = RpmpackagePackager.new(@plugin)
+          @packager.tmpdir = "/tmp"
           @packager.expects(:make_spec_file)
           PluginPackager.stubs(:do_quietly?).raises("foo")
           expect{
             @packager.create_package("", "")
-          }.to raise_error RuntimeError, "Could not build package. Reason - foo"
+          }.to raise_error(RuntimeError, "Could not build package. Reason - foo")
         end
       end
 
       describe "#make_spec_file" do
         before :each do
-          @packager = RpmpackagePackager.new("package")
+          @plugin = mock
+          @packager = RpmpackagePackager.new(@plugin)
         end
 
         it "should raise an exception if specfile cannot be built" do
           File.expects(:dirname).raises("test error")
           expect{
             @packager.make_spec_file
-          }.to raise_error RuntimeError, "Could not create specfile - test error"
+          }.to raise_error(RuntimeError, "Could not create specfile - test error")
         end
 
         it "should create the specfile from the erb" do
           File.stubs(:read).returns("specfile")
-          @packager.current_package_type = "test"
+          @plugin.stubs(:metadata).returns({:version => 2})
+          @packager.current_package_name = "test"
           @packager.tmpdir = maketmpdir
-          Dir.mkdir(File.join(@packager.tmpdir, "SPECS"))
+          Dir.mkdir(File.join(@packager.tmpdir, "test-2"))
           @packager.make_spec_file
-          File.read(File.join(@packager.tmpdir, "SPECS", "test.spec")).should == "specfile"
+          File.read(File.join(@packager.tmpdir, "test-2", "test-2.spec")).should == "specfile"
         end
       end
 
@@ -139,7 +147,6 @@ module MCollective
         it "should create the tmp dirs and cp the package files" do
           @plugin.stubs(:target_path).returns("")
           packager = RpmpackagePackager.new(@plugin)
-          packager.expects(:make_rpm_dirs)
           FileUtils.expects(:mkdir_p)
           File.stubs(:join).returns("/target")
           FileUtils.expects(:cp_r).with("test.rb", "/target")
@@ -147,29 +154,6 @@ module MCollective
         end
       end
 
-      describe "#make_rpm_dirs" do
-        before :each do
-          @packager = RpmpackagePackager.new("package")
-        end
-
-        it "should raise an exception if a directory can't be created" do
-          File.expects(:join).raises("test error")
-          expect{
-            @packager.make_rpm_dirs
-          }.to raise_error RuntimeError, "Could not create BUILD directory - test error"
-        end
-
-        it "should create the correct RPM build directories" do
-          @packager.tmpdir = maketmpdir
-          @packager.make_rpm_dirs
-          File.directory?(File.join(@packager.tmpdir, "SPECS")).should == true
-          File.directory?(File.join(@packager.tmpdir, "SOURCES")).should == true
-          File.directory?(File.join(@packager.tmpdir, "SRPMS")).should == true
-          File.directory?(File.join(@packager.tmpdir, "BUILD")).should == true
-          File.directory?(File.join(@packager.tmpdir, "RPMS")).should == true
-        end
-      end
-
       describe "#cleanup_tmpdirs" do
         it "should remove the temp directories" do
           packager = RpmpackagePackager.new("package")

data/spec/unit/plugins/mcollective/validator/array_validator_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/validator/array_validator.rb'
+
+module MCollective
+  module Validator
+    describe "#validate" do
+      it "should raise an exception if a given element is not defined in a given array" do
+        expect{
+          Validator::ArrayValidator.validate("element1",["element0", "element2"])
+        }.to raise_error(ValidatorError, "value should be one of element0, element2")
+      end
+
+      it "should not raise an exception if a given element is defined in a given array" do
+        Validator::ArrayValidator.validate("element1", ["element1", "element2"])
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/validator/ipv4address_validator_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/validator/ipv4address_validator.rb'
+
+module MCollective
+  module Validator
+    describe "#validate" do
+      it "should raise an exception if the supplied value is not an ipv4 address" do
+        expect{
+          Ipv4addressValidator.validate("foobar")
+        }.to raise_error(ValidatorError, "value should be an ipv4 address")
+      end
+
+      it "should not raise an exception if the supplied value is an ipv4 address" do
+        Ipv4addressValidator.validate("1.2.3.4")
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/validator/ipv6address_validator_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/validator/ipv6address_validator.rb'
+
+module MCollective
+  module Validator
+    describe "#validate" do
+      it "should raise an exception if the supplied value is not an ipv6 address" do
+        expect{
+          Ipv6addressValidator.validate("foobar")
+        }.to raise_error(ValidatorError, "value should be an ipv6 address")
+      end
+
+      it "should not raise an exception if the supplied value is an ipv6 address" do
+        Ipv6addressValidator.validate("2001:db8:85a3:8d3:1319:8a2e:370:7348")
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/validator/length_validator_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/validator/length_validator.rb'
+
+module MCollective
+  module Validator
+    describe "#validate" do
+      it "should raise an exception if the given string's length is greater than the given value" do
+        expect{
+          LengthValidator.validate("test", 3)
+        }.to raise_error(ValidatorError, "Input string is longer than 3 character(s)")
+      end
+
+      it "should not raise an exception if the given string's length is less than the given value" do
+        LengthValidator.validate("test", 4)
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/validator/regex_validator_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/validator/regex_validator.rb'
+
+module MCollective
+  module Validator
+    describe "#validate" do
+      it "should raise an exception if the given string does not matches the given regular expression" do
+        expect{
+          RegexValidator.validate("test", "nottest")
+        }.to raise_error(ValidatorError, "value should match nottest")
+      end
+
+      it "should not raise an exception if the given string's length is less than the given value" do
+        RegexValidator.validate("test", "test")
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/validator/shellsafe_validator_spec.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/validator/shellsafe_validator.rb'
+
+module MCollective
+  module Validator
+    describe "#validate" do
+      it "should raise an exception if the given string is not shellsafe" do
+        ['`', '$', ';', '|', '&&', '>', '<'].each do |chr|
+          expect{
+            ShellsafeValidator.validate("#{chr}test")
+          }.to raise_error(ValidatorError, "value should not have #{chr} in it")
+        end
+      end
+
+      it "should not raise an exception if the given string is shellsafe" do
+        ShellsafeValidator.validate("test")
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/validator/typecheck_validator_spec.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/validator/typecheck_validator.rb'
+
+module MCollective
+  module Validator
+    describe "#validate" do
+      it "should raise an exception if the given value is not of the supplied type" do
+        [[1, String], ['test', :integer], ['test', :float], ['test', :number], [1, :string], ['test', :boolean]].each do |val|
+          expect{
+            TypecheckValidator.validate(*val)
+          }.to raise_error(ValidatorError, "value should be a #{val[1].to_s}")
+        end
+      end
+
+      it "should not raise an exception if the given value is of the supplied type" do
+        [["test", String], [1, :integer], [1.2, :float], [1, :number], ["test", :string], [true, :boolean]].each do |val|
+          TypecheckValidator.validate(*val)
+        end
+      end
+    end
+  end
+end

data/spec/unit/registration/base_spec.rb

@@ -29,7 +29,7 @@ module MCollective
 
       describe "#msg_filter" do
         it "should target the registration agent" do
-          @reg.msg_filter.should == {"agent" => "registration"}
+          @reg.msg_filter["agent"].should == ["registration"]
         end
       end
 

data/spec/unit/rpc/actionrunner_spec.rb

@@ -185,7 +185,7 @@ module MCollective
         end
 
         it "should find the first match in the libdir" do
-          Config.any_instance.expects(:libdir).returns(["#{File::SEPARATOR}libdir1", "#{File::SEPARATOR}libdir2"])
+          Config.instance.expects(:libdir).returns(["#{File::SEPARATOR}libdir1", "#{File::SEPARATOR}libdir2"])
 
           action_in_first_dir = File.join(File::SEPARATOR, "libdir1", "agent", "spectester", "action.sh")
           action_in_last_dir = File.join(File::SEPARATOR, "libdir2", "agent", "spectester", "action.sh")
@@ -197,7 +197,7 @@ module MCollective
         end
 
         it "should find the match even in the last libdir" do
-          Config.any_instance.expects(:libdir).returns(["#{File::SEPARATOR}libdir1", "#{File::SEPARATOR}libdir2"])
+          Config.instance.expects(:libdir).returns(["#{File::SEPARATOR}libdir1", "#{File::SEPARATOR}libdir2"])
 
           action_in_first_dir = File.join(File::SEPARATOR, "libdir1", "agent", "spectester", "action.sh")
           action_in_last_dir = File.join(File::SEPARATOR, "libdir2", "agent", "spectester", "action.sh")

data/spec/unit/rpc/agent_spec.rb

@@ -6,11 +6,48 @@ module MCollective
   module RPC
     describe Agent do
       before do
+        ddl = stub
+        ddl.stubs(:meta).returns({})
+        DDL.stubs(:new).returns(ddl)
+
         @agent = Agent.new
         @agent.reply = {}
         @agent.request = {}
       end
 
+      describe "#meta" do
+        it "should be deprecated" do
+          Log.expects(:warn).with(regexp_matches(/setting meta data in agents have been deprecated/))
+          Agent.metadata("foo")
+        end
+      end
+
+      describe "#load_ddl" do
+        it "should load the correct DDL" do
+          ddl = stub
+          ddl.stubs(:meta).returns({:timeout => 5})
+
+          DDL.expects(:new).with("agent", :agent).returns(ddl)
+
+          Agent.new.timeout.should == 5
+        end
+
+        it "should fail if the DDL isn't loaded" do
+          DDL.expects(:new).raises("failed to load")
+          Log.expects(:error).once
+          expect { Agent.new }.to raise_error(DDLValidationError)
+        end
+
+        it "should default to 10 second timeout" do
+          ddl = stub
+          ddl.stubs(:meta).returns({})
+
+          DDL.expects(:new).with("agent", :agent).returns(ddl)
+
+          Agent.new.timeout.should == 10
+        end
+      end
+
       describe "#run" do
         before do
           @status = mock
@@ -83,71 +120,10 @@ module MCollective
           expect { @agent.send(:validate, :foo, String) }.to raise_error(MissingRPCData, "please supply a foo argument")
         end
 
-        it "should support regular expressions" do
-          @agent.request = {:foo => "this is a test, 123"}
-
-          expect { @agent.send(:validate, :foo, /foo/) }.to raise_error(InvalidRPCData, /foo should match/)
-          @agent.send(:validate, :foo, /is a test, \d\d\d$/)
-        end
-
-        it "should support type checking" do
-          @agent.request = {:str => "foo"}
-
-          expect { @agent.send(:validate, :str, Numeric) }.to raise_error(InvalidRPCData, /str should be a Numeric/)
-          @agent.send(:validate, :str, String)
-        end
-
-        it "should correctly validate ipv4 addresses" do
-          @agent.request = {:goodip4 => "1.1.1.1",
-                            :badip4  => "300.300.300.300"}
-
-          expect { @agent.send(:validate, :badip4, :ipv4address) }.to raise_error(InvalidRPCData, /badip4 should be an ipv4 address/)
-          @agent.send(:validate, :goodip4, :ipv4address)
-        end
-
-        it "should correctly validate ipv6 addresses" do
-          @agent.request = {:goodip6 => "2a00:1450:8006::93",
-                            :badip6  => "300.300.300.300"}
-
-          expect { @agent.send(:validate, :badip6, :ipv6address) }.to raise_error(InvalidRPCData, /badip6 should be an ipv6 address/)
-          @agent.send(:validate, :goodip6, :ipv6address)
-        end
-
-        it "should correctly validate boolean data" do
-          @agent.request = {:true => true, :false => false, :string => "foo", :number => 1}
-
-          @agent.send(:validate, :true, :boolean)
-          @agent.send(:validate, :false, :boolean)
-          expect { @agent.send(:validate, :string, :boolean) }.to raise_error(InvalidRPCData)
-          expect { @agent.send(:validate, :number, :boolean) }.to raise_error(InvalidRPCData)
-        end
-
-        it "should correctly validate list data" do
-          @agent.request = {:str => "foo"}
-          expect { @agent.send(:validate, :str, ["bar", "baz"]) }.to raise_error(InvalidRPCData, /str should be one of bar, baz/)
-
-          @agent.request = {:str => "foo"}
-          expect { @agent.send(:validate, :str, ["bar", "baz", "foo"]) }
-          @agent.send(:validate, :str, ["bar", "baz", "foo"])
-        end
-
-        it "should correctly identify characters that are not shell safe" do
-          @agent.request = {:backtick => 'foo`bar',
-                            :semicolon => 'foo;bar',
-                            :dollar => 'foo$(bar)',
-                            :pipe => 'foo|bar',
-                            :redirto => 'foo>bar',
-                            :inputfrom => 'foo<bar',
-                            :good => 'foo bar baz'}
-
-          expect { @agent.send(:validate, :backtick, :shellsafe) }.to raise_error(InvalidRPCData, /backtick should not have ` in it/)
-          expect { @agent.send(:validate, :semicolon, :shellsafe) }.to raise_error(InvalidRPCData, /semicolon should not have ; in it/)
-          expect { @agent.send(:validate, :dollar, :shellsafe) }.to raise_error(InvalidRPCData, /dollar should not have \$ in it/)
-          expect { @agent.send(:validate, :pipe, :shellsafe) }.to raise_error(InvalidRPCData, /pipe should not have \| in it/)
-          expect { @agent.send(:validate, :redirto, :shellsafe) }.to raise_error(InvalidRPCData, /redirto should not have > in it/)
-          expect { @agent.send(:validate, :inputfrom, :shellsafe) }.to raise_error(InvalidRPCData, /inputfrom should not have \< in it/)
-
-          @agent.send(:validate, :good, :shellsafe)
+        it "should catch validation errors and turn them into use case specific ones" do
+          @agent.request = {:input_key => "should be a number"}
+          Validator.expects(:validate).raises(ValidatorError, "input_key should be a number")
+          expect { @agent.send(:validate, :input_key, :number) }.to raise_error("Input input_key did not pass validation: input_key should be a number")
         end
       end
     end