mcollective-client 2.2.4 → 2.4.0

data/spec/unit/message_spec.rb

@@ -302,6 +302,30 @@ module MCollective
       end
     end
 
+    describe "#validate_compound_filter" do
+      let(:ddl) { mock }
+      let(:message) { Message.new("msg", "message", :type => :reply) }
+      let(:statement) { [{"fstatement" => {"name" => "rspec", "value" => "rspec_value", "params" => "rspec_param"} }] }
+
+      before do
+        Data.stubs(:pluginname).returns("rspec")
+        Data.stubs(:ddl_transform_input).with(ddl, "rspec_param").returns("rspec_param")
+        DDL.stubs(:new).returns(ddl)
+        Data.stubs(:ddl_validate).with(ddl, "rspec_param")
+      end
+
+      it "should correctly validate a compound filter" do
+        Data.stubs(:ddl_has_output?).with(ddl, "rspec_value").returns(true)
+        message.validate_compound_filter([statement])
+      end
+
+      it "should fail if an invalid value is queries" do
+        Data.stubs(:ddl_has_output?).with(ddl, "rspec_value").returns(false)
+        DDL.expects(:validation_fail!).with(:PLMC41, "Data plugin '%{functionname}()' does not return a '%{value}' value", :error, {:functionname => "rspec", :value => "rspec_value"})
+        message.validate_compound_filter([statement])
+      end
+    end
+
     describe "#validate" do
       it "should only validate requests" do
         m = Message.new("msg", "message", :type => :reply)

data/spec/unit/optionparser_spec.rb

@@ -109,5 +109,104 @@ module MCollective
         parser.parse[:collective].should == :rspec
       end
     end
+
+    describe '#add_common_options' do
+      before :each do
+        @parser = Optionparser.new
+      end
+
+      after :each do
+        ARGV.pop
+      end
+
+      it 'should parse the --target option' do
+        ARGV << '--target=rspec_collective'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:collective].should == 'rspec_collective'
+      end
+
+      it 'should parse the --discovery-timeout option' do
+        ARGV << '--discovery-timeout=1'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:disctimeout].should == 1
+      end
+
+      it 'should parse the --timeout option' do
+        ARGV << '--timeout=5'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:timeout].should == 5
+      end
+
+      it 'should parse the --quiet option' do
+        ARGV << '--quiet'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:verbose].should == false
+      end
+
+      it 'should parse the --ttl option' do
+        ARGV << '--ttl=9'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:ttl].should == 9
+      end
+
+      it 'should parse the --reply-to option' do
+        ARGV << '--reply-to=/rspec/test'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:reply_to].should == '/rspec/test'
+      end
+
+      it 'should parse the --disc-method option' do
+        ARGV << '--disc-method=flatfile'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:discovery_method].should == 'flatfile'
+      end
+
+      it 'should fail on the --disc-method option if the discovery method has already been set' do
+        @parser.instance_variable_get(:@options)[:discovery_method] = 'flatfile'
+        ARGV << '--disc-method=dm'
+        expect{
+          @parser.parse
+        }.to raise_error('Discovery method is already set by a competing option')
+      end
+
+      it 'should parse the --publish_timeout option' do
+        ARGV << '--publish_timeout=5'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:publish_timeout].should == 5
+      end
+
+      it 'should parse the --threaded option' do
+        ARGV << '--threaded'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:threaded].should == true
+      end
+
+      it 'should parse the --disc-option option' do
+        ARGV << '--disc-option=option1'
+        ARGV << '--disc-option=option2'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:discovery_options].should == ['option1', 'option2']
+        ARGV.pop
+      end
+
+      it 'should parse the --nodes option' do
+        File.expects(:readable?).with('nodes.txt').returns(true)
+        ARGV << '--nodes=nodes.txt'
+        @parser.parse
+        @parser.instance_variable_get(:@options)[:discovery_method].should == 'flatfile'
+        @parser.instance_variable_get(:@options)[:discovery_options].should == ['nodes.txt']
+      end
+
+      it 'should fail on the --nodes option if discovery_method or discovery_options have already been set' do
+      end
+
+      it 'should fail if it cannot read the discovery file' do
+        File.expects(:readable?).with('nodes.txt').returns(false)
+        ARGV << '--nodes=nodes.txt'
+        expect{
+          @parser.parse
+        }.to raise_error('Cannot read the discovery file nodes.txt')
+      end
+    end
   end
 end

data/spec/unit/pluginpackager/agent_definition_spec.rb

@@ -5,41 +5,70 @@ require 'spec_helper'
 module MCollective
   module PluginPackager
     describe AgentDefinition do
+
+      let(:configuration) do
+        {:target      => '.',
+         :pluginname  => 'test-package',
+         :revision    => nil,
+         :preinstall  => nil,
+         :postinstall => nil,
+         :version     => nil,
+         :mcname      => nil,
+         :mcversion   => nil,
+         :vendor      => nil,
+        }
+      end
+
       before :each do
         PluginPackager.expects(:get_metadata).once.returns({:name => "foo", :version => 1})
       end
 
       describe "#initialize" do
-
         before do
           AgentDefinition.any_instance.expects(:common)
         end
 
         it "should replace spaces in the package name with dashes" do
-          agent = AgentDefinition.new(".", "test package", nil, nil, nil, nil, [], {}, "agent")
+          configuration[:pluginname] = 'test-package'
+          agent = AgentDefinition.new(configuration, {}, "agent")
           agent.metadata[:name].should == "test-package"
         end
 
+         it "should set the version if passed from the config hash" do
+          configuration[:version] = '1.2.3'
+          agent = AgentDefinition.new(configuration, {}, "agent")
+          agent.metadata[:version].should == '1.2.3'
+        end
+
         it "should set dependencies if present" do
-          agent = AgentDefinition.new(".", "test-package", nil, nil, nil, nil, [:name => "foo", :version => nil], {}, "agent")
+          configuration[:dependency] = [:name => "foo", :version => nil]
+          agent = AgentDefinition.new(configuration, {}, "agent")
           agent.dependencies.should == [{:name => "foo", :version => nil}, {:name => "mcollective-common", :version => nil}]
         end
 
         it "should set mc name and version" do
-          agent = AgentDefinition.new(".", "test-package", nil, nil, nil, nil, [], {:mcname =>"pe-mcollective-common", :mcversion =>"1.2"}, "agent")
+          agent = AgentDefinition.new(configuration, {:mcname =>"pe-mcollective-common", :mcversion =>"1.2"}, "agent")
           agent.mcname.should == "pe-mcollective-common"
           agent.mcversion.should == "1.2"
         end
 
         it "should replace underscored with dashes in the name" do
-          agent = AgentDefinition.new(".", "test_package", nil, nil, nil, nil, [], {:mcname =>"pe-mcollective-common", :mcversion =>"1.2"}, "agent")
+          configuration[:pluginname] = 'test_package'
+          agent = AgentDefinition.new(configuration, {}, "agent")
           agent.metadata[:name].should == "test-package"
         end
 
         it "should replace whitespaces with a single dash in the name" do
-          agent = AgentDefinition.new(".", "test    package", nil, nil, nil, nil, [], {:mcname =>"pe-mcollective-common", :mcversion =>"1.2"}, "agent")
+          configuration[:pluginname] = 'test  package'
+          agent = AgentDefinition.new(configuration, {}, "agent")
           agent.metadata[:name].should == "test-package"
         end
+
+        it 'should set the correct vendor name' do
+          configuration[:vendor] = 'rspec'
+          agent = AgentDefinition.new(configuration, {}, "agent")
+          agent.vendor.should == 'rspec'
+        end
       end
 
       describe "#identify_packages" do
@@ -48,7 +77,7 @@ module MCollective
           AgentDefinition.any_instance.expects(:agent).once.returns(:check)
           AgentDefinition.any_instance.expects(:client).once.returns(:check)
 
-          agent = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+          agent = AgentDefinition.new(configuration, {}, "agent")
           agent.packagedata[:common].should == :check
           agent.packagedata[:agent].should == :check
           agent.packagedata[:client].should == :check
@@ -63,7 +92,7 @@ module MCollective
         it "should not populate the agent files if the agent directory is empty" do
           AgentDefinition.any_instance.expects(:common).returns(nil)
           PluginPackager.expects(:check_dir_present).returns(false)
-          agent = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+          agent = AgentDefinition.new(configuration, {}, "agent")
           agent.packagedata[:agent].should == nil
         end
 
@@ -76,7 +105,7 @@ module MCollective
           Dir.stubs(:glob).with("tmpdir/agent/*.ddl").returns([])
           Dir.stubs(:glob).with("tmpdir/agent/*").returns(["implementation.rb"])
 
-          agent = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+          agent = AgentDefinition.new(configuration, {}, "agent")
           agent.packagedata[:agent][:files].should == ["implementation.rb"]
         end
 
@@ -88,9 +117,10 @@ module MCollective
           File.stubs(:join).with(".", "aggregate").returns("tmpdir/aggregate")
           Dir.stubs(:glob).returns([])
 
-          agent = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+          configuration[:pluginname] = 'foo'
+          agent = AgentDefinition.new(configuration, {}, "agent")
           agent.packagedata[:agent][:dependencies].should == [{:name => "mcollective-common", :version => nil}]
-          agent.packagedata[:agent][:plugindependency].should == {:name => "mcollective-foo-common", :version =>1, :iteration => 1}
+          agent.packagedata[:agent][:plugindependency].should == {:name => "mcollective-foo-common", :version =>1, :revision => 1}
         end
       end
 
@@ -107,7 +137,7 @@ module MCollective
           Dir.expects(:glob).with("validatordir").returns(["validator.rb"])
           Dir.expects(:glob).with("ddldir").returns(["agent.ddl"])
 
-          common = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+          common = AgentDefinition.new(configuration, {}, "agent")
           common.packagedata[:common][:files].should == ["data.rb", "util.rb", "validator.rb", "agent.ddl"]
         end
 
@@ -123,7 +153,7 @@ module MCollective
           Dir.expects(:glob).with("ddldir").returns([])
 
           expect{
-            common = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+            common = AgentDefinition.new(configuration, {}, "agent")
           }.to raise_error(RuntimeError, "cannot create package - No ddl file found in ddldir")
         end
       end
@@ -143,7 +173,7 @@ module MCollective
           Dir.expects(:glob).with("clientdir/*").returns(["client.rb"])
           Dir.expects(:glob).with("aggregatedir/*").returns(["aggregate.rb"])
 
-          client = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+          client = AgentDefinition.new(configuration, {}, "agent")
           client.packagedata[:client][:files].should == ["client.rb",  "aggregate.rb"]
         end
 
@@ -151,7 +181,7 @@ module MCollective
           AgentDefinition.any_instance.expects(:common).returns(nil)
           PluginPackager.expects(:check_dir_present).times(2).returns(false)
 
-          client = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+          client = AgentDefinition.new(configuration, {}, "agent")
           client.packagedata[:client].should == nil
         end
 
@@ -162,10 +192,11 @@ module MCollective
           File.expects(:join).with("aggregatedir", "*").returns("aggregatedir/*")
           Dir.expects(:glob).with("clientdir/*").returns(["client.rb"])
           Dir.expects(:glob).with("aggregatedir/*").returns(["aggregate.rb"])
+          configuration[:pluginname] = 'foo'
 
-          client = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+          client = AgentDefinition.new(configuration, {}, "agent")
           client.packagedata[:client][:dependencies].should == [{:name => "mcollective-common", :version => nil}]
-          client.packagedata[:client][:plugindependency].should == {:name => "mcollective-foo-common", :version => 1, :iteration => 1}
+          client.packagedata[:client][:plugindependency].should == {:name => "mcollective-foo-common", :version => 1, :revision => 1}
         end
       end
     end

data/spec/unit/pluginpackager/standard_definition_spec.rb

@@ -5,36 +5,59 @@ require 'spec_helper'
 module MCollective
   module PluginPackager
     describe StandardDefinition do
+
+      let(:configuration) do
+        {:target      => '.',
+         :pluginname  => 'test-package',
+         :revision    => nil,
+         :preinstall  => nil,
+         :postinstall => nil,
+         :version     => nil,
+         :mcname      => nil,
+         :mcversion   => nil
+        }
+      end
+
       before :each do
         PluginPackager.expects(:get_metadata).once.returns({:name => "foo", :version => 1})
       end
 
       describe "#initialize" do
-        it "should replace spaces in the package name with dashes" do
-          plugin = StandardDefinition.new(".", "test plugin", nil, nil, nil, nil, [], {}, "testplugin")
+        it "should replace whitespaces in the package name with dashes" do
+          configuration[:pluginname] = 'test   plugin'
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
           plugin.metadata[:name].should == "test-plugin"
         end
 
+        it "should set the version if passed from the config hash" do
+          configuration[:version] = '1.2.3'
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
+          plugin.metadata[:version].should == '1.2.3'
+        end
+
         it "should set dependencies if present" do
-          plugin = StandardDefinition.new(".", "test plugin", nil, nil, nil, nil, [{:name => "foo", :version => nil}], {}, "testplugin")
+          configuration[:dependency] = [{:name => "foo", :version => nil}]
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
           plugin.dependencies.should == [{:name => "foo", :version => nil},
                                          {:name => "mcollective-common", :version => nil}]
         end
 
         it "should set mc name and version dependencies" do
-          plugin = StandardDefinition.new(".", "test plugin", nil, nil, nil, nil, [], {:mcname => "pe-mcollective", :mcversion => "1"}, "testplugin")
+          plugin = StandardDefinition.new(configuration, {:mcname => "pe-mcollective", :mcversion => "1"}, "testplugin")
           plugin.mcname.should == "pe-mcollective"
           plugin.mcversion.should == "1"
         end
 
         it "should replace underscores with dashes in the name" do
-          plugin = StandardDefinition.new(".", "test_plugin", nil, nil, nil, nil, [], {:mcname => "pe-mcollective", :mcversion => "1"}, "testplugin")
+          configuration[:pluginname] = 'test_plugin'
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
           plugin.metadata[:name].should == "test-plugin"
         end
 
-        it "should replace whitespaces with a single dash in the name" do
-          plugin = StandardDefinition.new(".", "test  plugin", nil, nil, nil, nil, [], {:mcname => "pe-mcollective", :mcversion => "1"}, "testplugin")
-          plugin.metadata[:name].should == "test-plugin"
+        it 'should set the correct vendor name' do
+          configuration[:vendor] = 'rspec'
+          agent = StandardDefinition.new(configuration, {}, "agent")
+          agent.vendor.should == 'rspec'
         end
       end
 
@@ -43,9 +66,9 @@ module MCollective
           StandardDefinition.any_instance.expects(:common).once.returns(:check)
           StandardDefinition.any_instance.expects(:plugin).once.returns(:check)
 
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
           plugin.packagedata[:common].should == :check
-          plugin.packagedata["testplugin"].should == :check
+          plugin.packagedata[:testplugin].should == :check
         end
       end
 
@@ -54,26 +77,27 @@ module MCollective
         it "should return nil if the plugin doesn't contain any files" do
           StandardDefinition.any_instance.expects(:common).returns(nil)
           PluginPackager.expects(:check_dir_present).returns(false)
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
-          plugin.packagedata["testplugin"].should == nil
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
+          plugin.packagedata[:testplugin].should == nil
         end
 
         it "should add plugin files to the file list" do
           StandardDefinition.any_instance.expects(:common).returns(nil)
           PluginPackager.expects(:check_dir_present).returns(true)
           Dir.expects(:glob).with("./testplugin/*").returns(["file.rb"])
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
-          plugin.packagedata["testplugin"][:files].should == ["file.rb"]
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
+          plugin.packagedata[:testplugin][:files].should == ["file.rb"]
         end
 
         it "should add common package as dependency if present" do
+          configuration[:pluginname] = 'foo'
           StandardDefinition.any_instance.expects(:common).returns(true)
           PluginPackager.expects(:check_dir_present).returns(true)
           Dir.expects(:glob).with("./testplugin/*").returns(["file.rb"])
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
-          plugin.packagedata["testplugin"][:files].should == ["file.rb"]
-          plugin.packagedata["testplugin"][:dependencies].should == [{:name => "mcollective-common", :version => nil}]
-          plugin.packagedata["testplugin"][:plugindependency].should == {:name => "mcollective-foo-common", :version => 1, :iteration => 1}
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
+          plugin.packagedata[:testplugin][:files].should == ["file.rb"]
+          plugin.packagedata[:testplugin][:dependencies].should == [{:name => "mcollective-common", :version => nil}]
+          plugin.packagedata[:testplugin][:plugindependency].should == {:name => "mcollective-foo-common", :version => 1, :revision => 1}
         end
       end
 
@@ -84,14 +108,14 @@ module MCollective
 
         it "should return nil if common doesn't contain any files" do
           PluginPackager.expects(:check_dir_present).returns(false)
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
           plugin.packagedata[:common].should == nil
         end
 
         it "should add common files to the file list" do
           PluginPackager.expects(:check_dir_present).returns(true)
           Dir.expects(:glob).with("./util/*").returns(["common.rb"])
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
+          plugin = StandardDefinition.new(configuration, {}, "testplugin")
           plugin.packagedata[:common][:files].should == ["common.rb"]
         end
       end

data/spec/unit/pluginpackager_spec.rb

@@ -75,16 +75,16 @@ module MCollective
       end
     end
 
-    describe "#do_quietly?" do
+    describe "#execute_verbosely" do
       it "should call the block parameter if verbose is true" do
-        result = PluginPackager.do_quietly?(true) {:success}
+        result = PluginPackager.execute_verbosely(true) {:success}
         result.should == :success
       end
 
       it "should call the block parameter quietly if verbose is false" do
         std_out = Tempfile.new("mc_pluginpackager_spec")
         File.expects(:new).with("/dev/null", "w").returns(std_out)
-        PluginPackager.do_quietly?(false) {puts "success"}
+        PluginPackager.execute_verbosely(false) {puts "success"}
         std_out.rewind
         std_out.read.should == "success\n"
         std_out.close
@@ -93,23 +93,23 @@ module MCollective
 
       it "should raise an exception and reset stdout if the block raises an execption" do
         expect{
-          PluginPackager.do_quietly?(false) {raise Exception, "exception"}
+          PluginPackager.execute_verbosely(false) {raise Exception, "exception"}
         }.to raise_error(Exception, "exception")
       end
     end
 
-    describe "#build_tool?" do
+    describe "#command_available?" do
       it "should return true if the given build tool is present on the system" do
         File.expects(:join).returns("foo")
         File.expects(:exists?).with("foo").returns(true)
-        result = PluginPackager.build_tool?("foo")
+        result = PluginPackager.command_available?("foo")
         result.should == true
       end
 
       it "should return false if the given build tool is not present on the system" do
         File.stubs(:join).returns("foo")
         File.stubs(:exists?).with("foo").returns(false)
-        result = PluginPackager.build_tool?("foo")
+        result = PluginPackager.command_available?("foo")
         result.should == false
       end
     end
@@ -127,5 +127,29 @@ module MCollective
         }.to raise_error(RuntimeError, "Failed: foo")
       end
     end
+
+    describe '#filter_dependencies' do
+      before :each do
+        @dependencies = [{:name => 'rspec', :version => '1.0'}]
+      end
+
+      it 'should leave normal dependencies intact' do
+        result = PluginPackager.filter_dependencies('debian', @dependencies)
+        result.should == @dependencies
+      end
+
+      it 'should filter out dependencies with the incorrect prefix' do
+        @dependencies << {:name => 'redhat::rspec_redhat', :version => '2.0'}
+        result = PluginPackager.filter_dependencies('debian', @dependencies)
+        result.should == [{:name => 'rspec', :version => '1.0'}]
+      end
+
+      it 'should reformat dependencies with the correct prefix' do
+        @dependencies << {:name => 'debian::rspec_debian', :version => '2.0'}
+        result = PluginPackager.filter_dependencies('debian', @dependencies)
+        result.should == [{:name => 'rspec', :version => '1.0'},
+                          {:name => 'rspec_debian', :version => '2.0'}]
+      end
+    end
   end
 end