mcollective-client 2.0.0 → 2.2.0

data/spec/unit/matcher_spec.rb

@@ -0,0 +1,260 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Matcher do
+    describe "#create_function_hash" do
+      it "should create a correct hash for a 'normal' function call using single quotes" do
+        result = Matcher.create_function_hash("foo('bar').res=1")
+        result["value"].should == "res"
+        result["params"].should == "bar"
+        result["r_compare"].should == "1"
+        result["operator"].should == "=="
+        result["name"].should == "foo"
+      end
+
+      it "should create a correct hash for a 'normal' function call using double quotes" do
+        result = Matcher.create_function_hash('foo("bar").res=1')
+        result["value"].should == "res"
+        result["params"].should == "bar"
+        result["r_compare"].should == "1"
+        result["operator"].should == "=="
+        result["name"].should == "foo"
+       end
+
+      it "should create a correct hash when a paramater contains a dot value" do
+        result = Matcher.create_function_hash("foo('bar.1').res=1")
+        result["value"].should == "res"
+        result["params"].should == "bar.1"
+        result["r_compare"].should == "1"
+        result["operator"].should == "=="
+        result["name"].should == "foo"
+      end
+
+      it "should create a correct hash when right compare value is a regex" do
+        result = Matcher.create_function_hash("foo('bar').res=/reg/")
+        result["value"].should == "res"
+        result["params"].should == "bar"
+        result["r_compare"].should == /reg/
+        result["operator"].should == "=~"
+        result["name"].should == "foo"
+      end
+
+      it "should create a correct hash when the operator is >= or <=" do
+        result = Matcher.create_function_hash("foo('bar').res<=1")
+        result["value"].should == "res"
+        result["params"].should == "bar"
+        result["r_compare"].should == "1"
+        result["operator"].should == "<="
+        result["name"].should == "foo"
+
+        result = Matcher.create_function_hash("foo('bar').res>=1")
+        result["value"].should == "res"
+        result["params"].should == "bar"
+        result["r_compare"].should == "1"
+        result["operator"].should == ">="
+        result["name"].should == "foo"
+      end
+
+      it "should create a correct hash when no dot value is present" do
+        result = Matcher.create_function_hash("foo('bar')<=1")
+        result["value"].should == nil
+        result["params"].should == "bar"
+        result["r_compare"].should == "1"
+        result["operator"].should == "<="
+        result["name"].should == "foo"
+      end
+
+      it "should create a correct hash when a dot is present in a parameter but no dot value is present" do
+        result = Matcher.create_function_hash("foo('bar.one')<=1")
+        result["value"].should == nil
+        result["params"].should == "bar.one"
+        result["r_compare"].should == "1"
+        result["operator"].should == "<="
+        result["name"].should == "foo"
+      end
+
+      it "should create a correct hash when multiple dots are present in parameters but no dot value is present" do
+        result = Matcher.create_function_hash("foo('bar.one.two, bar.three.four')<=1")
+        result["value"].should == nil
+        result["params"].should == "bar.one.two, bar.three.four"
+        result["r_compare"].should == "1"
+        result["operator"].should == "<="
+        result["name"].should == "foo"
+      end
+
+      it "should create a correct hash when no parameters are given" do
+        result = Matcher.create_function_hash("foo()<=1")
+        result["value"].should == nil
+        result["params"].should == nil
+        result["r_compare"].should == "1"
+        result["operator"].should == "<="
+        result["name"].should == "foo"
+     end
+
+      it "should create a correct hash parameters are empty strings" do
+        result = Matcher.create_function_hash("foo('')=1")
+        result["value"].should == nil
+        result["params"].should == ""
+        result["r_compare"].should == "1"
+        result["operator"].should == "=="
+        result["name"].should == "foo"
+      end
+    end
+
+    describe "#execute_function" do
+      it "should return the result of an evaluated function with a dot value" do
+        data = mock
+        data.expects(:send).with("value").returns("success")
+        MCollective::Data.expects(:send).with("foo", "bar").returns(data)
+        result = Matcher.execute_function({"name" => "foo", "params" => "bar", "value" => "value"})
+        result.should == "success"
+      end
+
+      it "should return the result of an evaluated function without a dot value" do
+        MCollective::Data.expects(:send).with("foo", "bar").returns("success")
+        result = Matcher.execute_function({"name" => "foo", "params" => "bar"})
+        result.should == "success"
+      end
+    end
+
+    describe "#eval_compound_statement" do
+      it "should return correctly on a regex class statement" do
+        Util.expects(:has_cf_class?).with("/foo/").returns(true)
+        Matcher.eval_compound_statement({"statement" => "/foo/"}).should == true
+        Util.expects(:has_cf_class?).with("/foo/").returns(false)
+        Matcher.eval_compound_statement({"statement" => "/foo/"}).should == false
+      end
+
+      it "should return correcly for string and regex facts" do
+        Util.expects(:has_fact?).with("foo", "bar", "==").returns(true)
+        Matcher.eval_compound_statement({"statement" => "foo=bar"}).should == "true"
+        Util.expects(:has_fact?).with("foo", "/bar/", "=~").returns(false)
+        Matcher.eval_compound_statement({"statement" => "foo=/bar/"}).should == "false"
+      end
+
+      it "should return correctly on a string class statement" do
+        Util.expects(:has_cf_class?).with("foo").returns(true)
+        Matcher.eval_compound_statement({"statement" => "foo"}).should == true
+        Util.expects(:has_cf_class?).with("foo").returns(false)
+        Matcher.eval_compound_statement({"statement" => "foo"}).should == false
+      end
+    end
+
+    describe "#eval_compound_fstatement" do
+      describe "it should return false if a string, true or false are compared with > or <" do
+        let(:function_hash) do
+          {"name" => "foo",
+           "params" => "bar",
+           "value" => "value",
+           "operator" => "<",
+           "r_compare" => "teststring"}
+        end
+
+
+        it "should return false if a string is compare with a < or >" do
+          Matcher.expects(:execute_function).returns("teststring")
+          result = Matcher.eval_compound_fstatement(function_hash)
+          result.should == false
+        end
+
+        it "should return false if a TrueClass is compared with a < or > " do
+          Matcher.expects(:execute_function).returns(true)
+          result = Matcher.eval_compound_fstatement(function_hash)
+          result.should == false
+        end
+
+        it "should return false if a FalseClass is compared with a < or >" do
+          Matcher.expects(:execute_function).returns(false)
+          result = Matcher.eval_compound_fstatement(function_hash)
+          result.should == false
+        end
+      end
+
+      describe "it should return false if backticks are present in parameters and if non strings are compared with regex's" do
+        before :each do
+          @function_hash = {"name" => "foo",
+                           "params" => "bar",
+                           "value" => "value",
+                           "operator" => "=",
+                           "r_compare" => "1"}
+        end
+
+        it "should return false if a backtick is present in a parameter" do
+          @function_hash["params"] = "`bar`"
+          Matcher.expects(:execute_function).returns("teststring")
+          MCollective::Log.expects(:debug).with("Cannot use backticks in function parameters")
+          result = Matcher.eval_compound_fstatement(@function_hash)
+          result.should == false
+        end
+
+        it "should return false if left compare object isn't a string and right compare is a regex" do
+          Matcher.expects(:execute_function).returns(1)
+          @function_hash["r_compare"] = "/foo/"
+          @function_hash["operator"] = "=~"
+          MCollective::Log.expects(:debug).with("Cannot do a regex check on a non string value.")
+          result = Matcher.eval_compound_fstatement(@function_hash)
+          result.should == false
+        end
+      end
+
+      describe "it should return the expected result for valid function hashes" do
+        before :each do
+          @function_hash = {"name" => "foo",
+                            "params" => "bar",
+                            "value" => "value",
+                            "operator" => "=",
+                            "r_compare" => ""}
+        end
+
+        it "should return true if right value is a regex and matches the left value" do
+          Matcher.expects(:execute_function).returns("teststring")
+          @function_hash["r_compare"] = /teststring/
+          @function_hash["operator"] = "=~"
+          result = Matcher.eval_compound_fstatement(@function_hash)
+          result.should == true
+        end
+
+        it "should return false if right value is a regex, operator is != and regex equals left value" do
+          Matcher.expects(:execute_function).returns("teststring")
+          @function_hash["r_compare"] = /teststring/
+          @function_hash["operator"] = "!=~"
+          result = Matcher.eval_compound_fstatement(@function_hash)
+          result.should == false
+        end
+
+        it "should return false if right value is a regex and does not match left value" do
+          Matcher.expects(:execute_function).returns("testsnotstring")
+          @function_hash["r_compare"] = /teststring/
+          @function_hash["operator"] = "=~"
+          result = Matcher.eval_compound_fstatement(@function_hash)
+          result.should == false
+        end
+
+        it "should return true if left value logically compares to the right value" do
+          Matcher.expects(:execute_function).returns(1)
+          @function_hash["r_compare"] = 1
+          @function_hash["operator"] = ">="
+          result = Matcher.eval_compound_fstatement(@function_hash)
+          result.should == true
+       end
+
+        it "should return false if left value does not logically compare to right value" do
+          Matcher.expects(:execute_function).returns("1")
+          @function_hash["r_compare"] = "1"
+          @function_hash["operator"] = ">"
+          result = Matcher.eval_compound_fstatement(@function_hash)
+          result.should == false
+        end
+      end
+    end
+
+    describe "#create_compound_callstack" do
+      it "should create a callstack from a valid call_string" do
+        result = Matcher.create_compound_callstack("foo('bar')=1 and bar=/bar/")
+        result.should == [{"fstatement" => {"params"=>"bar", "name"=>"foo", "operator"=>"==", "r_compare"=>"1"}}, {"and" => "and"}, {"statement" => "bar=/bar/"}]
+      end
+    end
+  end
+end

data/spec/unit/message_spec.rb

@@ -67,7 +67,7 @@ module MCollective
 
     describe "#reply_to=" do
       it "should only set the reply-to header for requests" do
-        Config.instance.instance_variable_set("@direct_addressing", true)
+        Config.instance.expects(:direct_addressing).returns(true)
         m = Message.new("payload", "message", :type => :reply)
         m.discovered_hosts = ["foo"]
         expect { m.reply_to = "foo" }.to raise_error(/reply targets/)
@@ -146,7 +146,7 @@ module MCollective
     describe "#type=" do
       it "should only allow types to be set when discovered hosts were given" do
         m = Message.new("payload", "message")
-        Config.instance.instance_variable_set("@direct_addressing", true)
+        Config.instance.stubs(:direct_addressing).returns(true)
 
         expect {
           m.type = :direct_request
@@ -155,7 +155,7 @@ module MCollective
 
       it "should not allow direct_request to be set if direct addressing isnt enabled" do
         m = Message.new("payload", "message")
-        Config.instance.instance_variable_set("@direct_addressing", false)
+        Config.instance.stubs(:direct_addressing).returns(false)
 
         expect {
           m.type = :direct_request
@@ -164,13 +164,24 @@ module MCollective
 
       it "should only accept valid types" do
         m = Message.new("payload", "message")
-        Config.instance.instance_variable_set("@direct_addressing", true)
+        Config.instance.stubs(:direct_addressing).returns(true)
 
         expect {
           m.type = :foo
         }.to raise_error("Unknown message type foo")
       end
 
+      it "should clear the filter in direct_request mode and add just an agent filter" do
+        m = Message.new("payload", "message")
+        m.discovered_hosts = ["rspec"]
+        Config.instance.stubs(:direct_addressing).returns(true)
+
+        m.filter = Util.empty_filter.merge({"cf_class" => ["test"]})
+        m.agent = "rspec"
+        m.type = :direct_request
+        m.filter.should == Util.empty_filter.merge({"agent" => ["rspec"]})
+      end
+
       it "should set the type" do
         m = Message.new("payload", "message")
         m.type = :request
@@ -201,7 +212,7 @@ module MCollective
         security.expects(:encoderequest).with("identity", 'payload', '123', Util.empty_filter, 'rspec_agent', 'mcollective', 60).twice
         PluginManager.expects("[]").with("security_plugin").returns(security).twice
 
-        Config.any_instance.expects(:identity).returns("identity").times(4)
+        Config.instance.expects(:identity).returns("identity").twice
 
         Message.any_instance.expects(:requestid).returns("123").twice
 
@@ -212,6 +223,20 @@ module MCollective
         m.encode!
       end
 
+      it "should retain the requestid if it was specifically set" do
+        security = mock
+        security.expects(:encoderequest).with("identity", 'payload', '123', Util.empty_filter, 'rspec_agent', 'mcollective', 60)
+        PluginManager.expects("[]").with("security_plugin").returns(security)
+
+        Config.instance.expects(:identity).returns("identity")
+
+        m = Message.new("payload", "message", :type => :request, :agent => "rspec_agent", :collective => "mcollective")
+        m.expects(:create_reqid).never
+        m.requestid = "123"
+        m.encode!
+        m.requestid.should == "123"
+      end
+
       it "should not allow bad callerids when replying" do
         request = mock
         request.stubs(:agent).returns("rspec_agent")
@@ -358,8 +383,8 @@ module MCollective
         m = Message.new("msg", "message", :type => :request)
         m.discovered_hosts = ["one", "two", "three"]
 
-        Config.any_instance.expects(:direct_addressing).returns(true)
-        Config.any_instance.expects(:direct_addressing_threshold).returns(10)
+        Config.instance.stubs(:direct_addressing).returns(true)
+        Config.instance.stubs(:direct_addressing_threshold).returns(10)
 
         connector = mock
         connector.expects(:publish).with(m)
@@ -373,8 +398,8 @@ module MCollective
         m = Message.new("msg", "message", :type => :request)
         m.discovered_hosts = ["one", "two", "three"]
 
-        Config.any_instance.expects(:direct_addressing).returns(true)
-        Config.any_instance.expects(:direct_addressing_threshold).returns(1)
+        Config.instance.expects(:direct_addressing).returns(true)
+        Config.instance.expects(:direct_addressing_threshold).returns(1)
 
         connector = mock
         connector.expects(:publish).with(m)
@@ -389,10 +414,7 @@ module MCollective
       it "should create a valid request id" do
         m = Message.new("msg", "message", :agent => "rspec", :collective => "mc")
 
-        Config.any_instance.expects(:identity).returns("rspec")
-        Time.expects(:now).returns(1.1)
-
-        Digest::MD5.expects(:hexdigest).with("rspec-1.1-rspec-mc").returns("reqid")
+        SSL.expects(:uuid).returns("reqid")
 
         m.create_reqid.should == "reqid"
       end

data/spec/unit/optionparser_spec.rb

@@ -97,7 +97,7 @@ module MCollective
         parser = Optionparser.new(defaults={:collective => "rspec"})
         parser.stubs(:add_required_options)
         parser.stubs(:add_common_options)
-        Config.any_instance.expects(:main_collective).never
+        Config.instance.expects(:main_collective).never
         parser.parse
       end
 
@@ -105,7 +105,7 @@ module MCollective
         parser = Optionparser.new(defaults={})
         parser.stubs(:add_required_options)
         parser.stubs(:add_common_options)
-        Config.any_instance.expects(:main_collective).returns(:rspec).once
+        Config.instance.expects(:main_collective).returns(:rspec).once
         parser.parse[:collective].should == :rspec
       end
     end

data/spec/unit/pluginpackager/agent_definition_spec.rb

@@ -6,25 +6,27 @@ module MCollective
   module PluginPackager
     describe AgentDefinition do
       before :each do
-        PluginPackager.expects(:get_metadata).once.returns({:name => "foo"})
+        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
+          AgentDefinition.any_instance.expects(:common)
           agent = AgentDefinition.new(".", "test package", nil, nil, nil, nil, [], {}, "agent")
           agent.metadata[:name].should == "test-package"
         end
 
         it "should set dependencies if present" do
-          agent = AgentDefinition.new(".", "test-package", nil, nil, nil, nil, ["foo"], {}, "agent")
-          agent.dependencies.should == ["foo"]
+          AgentDefinition.any_instance.expects(:common)
+          agent = AgentDefinition.new(".", "test-package", nil, nil, nil, nil, [:name => "foo", :version => nil], {}, "agent")
+          agent.dependencies.should == [{:name => "foo", :version => nil}, {:name => "mcollective-common", :version => nil}]
         end
 
-        it "should set mc server, client and common dependencies" do
-          agent = AgentDefinition.new(".", "test-package", nil, nil, nil, nil, [], {:server => "pe-mcollective"}, "agent")
-          agent.mcserver.should == "pe-mcollective"
-          agent.mcclient.should == "mcollective-client"
-          agent.mccommon.should == "mcollective-common"
+        it "should set mc name and version" do
+          AgentDefinition.any_instance.expects(:common)
+          agent = AgentDefinition.new(".", "test-package", nil, nil, nil, nil, [], {:mcname =>"pe-mcollective-common", :mcversion =>"1.2"}, "agent")
+          agent.mcname.should == "pe-mcollective-common"
+          agent.mcversion.should == "1.2"
         end
       end
 
@@ -53,45 +55,64 @@ module MCollective
           agent.packagedata[:agent].should == nil
         end
 
-        it "should populate the agent files if the agent directory is present and not empty" do
+        it "should add the agent file if the agent directory and implementation file is present" do
           AgentDefinition.any_instance.expects(:common).returns(nil)
-          PluginPackager.expects(:check_dir_present).returns(true)
-          File.stubs(:join).returns("tmpdir")
-          Dir.stubs(:glob).returns(["file.rb", "implementation.rb"])
+          PluginPackager.stubs(:check_dir_present).returns(true)
+          File.stubs(:join).with(".", "agent").returns("tmpdir/agent")
+          File.stubs(:join).with("tmpdir/agent", "*.ddl").returns("tmpdir/agent/*.ddl")
+          File.stubs(:join).with("tmpdir/agent", "*").returns("tmpdir/agent/*")
+          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.packagedata[:agent][:files].should == ["file.rb", "implementation.rb"]
+          agent.packagedata[:agent][:files].should == ["implementation.rb"]
         end
 
         it "should add common package as dependency if present" do
           AgentDefinition.any_instance.expects(:common).returns({:files=> ["test.rb"]})
-          PluginPackager.expects(:check_dir_present).returns(true)
-          File.stubs(:join).returns("tmpdir")
+          PluginPackager.expects(:check_dir_present).with("tmpdir/agent").returns(true)
+          File.stubs(:join).returns("/tmp")
+          File.stubs(:join).with(".", "agent").returns("tmpdir/agent")
+          File.stubs(:join).with(".", "aggregate").returns("tmpdir/aggregate")
           Dir.stubs(:glob).returns([])
 
           agent = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
-          agent.packagedata[:agent][:dependencies].should == ["mcollective", "mcollective-foo-common"]
+          agent.packagedata[:agent][:dependencies].should == [{:name => "mcollective-common", :version => nil},
+                                                              {:name => "mcollective-foo-common", :version =>1}]
         end
       end
 
       describe "#common" do
-        before do
+        it "should populate the common files if there are any" do
           AgentDefinition.any_instance.expects(:agent)
           AgentDefinition.any_instance.expects(:client)
-        end
+          File.expects(:join).with(".", "data", "**").returns("datadir")
+          File.expects(:join).with(".", "util", "**", "**").returns("utildir")
+          File.expects(:join).with(".", "agent", "*.ddl").returns("ddldir")
+          File.expects(:join).with(".", "validator", "**").returns("validatordir")
+          Dir.expects(:glob).with("datadir").returns(["data.rb"])
+          Dir.expects(:glob).with("utildir").returns(["util.rb"])
+          Dir.expects(:glob).with("validatordir").returns(["validator.rb"])
+          Dir.expects(:glob).with("ddldir").returns(["agent.ddl"])
 
-        it "should not populate the commong files if the util directory is empty" do
-          PluginPackager.expects(:check_dir_present).returns(false)
           common = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
-          common.packagedata[:common].should == nil
+          common.packagedata[:common][:files].should == ["data.rb", "util.rb", "validator.rb", "agent.ddl"]
         end
 
-        it "should populate the common files if the common directory is present and not empty" do
-          PluginPackager.expects(:check_dir_present).returns(true)
-          File.stubs(:join).returns("tmpdir")
-          Dir.stubs(:glob).returns(["file.rb"])
-          common = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
-          common.packagedata[:common][:files].should == ["file.rb"]
+        it "should raise an exception if the ddl file isn't present" do
+          File.expects(:join).with(".", "data", "**").returns("datadir")
+          File.expects(:join).with(".", "util", "**", "**").returns("utildir")
+          File.expects(:join).with(".", "agent", "*.ddl").returns("ddldir")
+          File.expects(:join).with(".", "agent").returns("ddldir")
+          File.expects(:join).with(".", "validator", "**").returns("validatordir")
+          Dir.expects(:glob).with("datadir").returns(["data.rb"])
+          Dir.expects(:glob).with("utildir").returns(["util.rb"])
+          Dir.expects(:glob).with("validatordir").returns(["validator.rb"])
+          Dir.expects(:glob).with("ddldir").returns([])
+
+          expect{
+            common = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
+          }.to raise_error(RuntimeError, "cannot create package - No ddl file found in ddldir")
         end
       end
 
@@ -99,27 +120,24 @@ module MCollective
         before do
           AgentDefinition.any_instance.expects(:agent).returns(nil)
           File.expects(:join).with(".", "application").returns("clientdir")
-          File.expects(:join).with(".", "bin").returns("bindir")
-          File.expects(:join).with(".", "agent").returns("agentdir")
+          File.expects(:join).with(".", "aggregate").returns("aggregatedir")
         end
 
         it "should populate client files if all directories are present" do
           AgentDefinition.any_instance.expects(:common).returns(nil)
-          PluginPackager.expects(:check_dir_present).times(3).returns(true)
+          PluginPackager.expects(:check_dir_present).times(2).returns(true)
           File.expects(:join).with("clientdir", "*").returns("clientdir/*")
-          File.expects(:join).with("bindir", "*").returns("bindir/*")
-          File.expects(:join).with("agentdir", "*.ddl").returns("agentdir/*.ddl")
+          File.expects(:join).with("aggregatedir", "*").returns("aggregatedir/*")
           Dir.expects(:glob).with("clientdir/*").returns(["client.rb"])
-          Dir.expects(:glob).with("bindir/*").returns(["bin.rb"])
-          Dir.expects(:glob).with("agentdir/*.ddl").returns(["agent.ddl"])
+          Dir.expects(:glob).with("aggregatedir/*").returns(["aggregate.rb"])
 
           client = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
-          client.packagedata[:client][:files].should == ["client.rb", "bin.rb", "agent.ddl"]
+          client.packagedata[:client][:files].should == ["client.rb",  "aggregate.rb"]
         end
 
         it "should not populate client files if directories are not present" do
           AgentDefinition.any_instance.expects(:common).returns(nil)
-          PluginPackager.expects(:check_dir_present).times(3).returns(false)
+          PluginPackager.expects(:check_dir_present).times(2).returns(false)
 
           client = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
           client.packagedata[:client].should == nil
@@ -127,16 +145,15 @@ module MCollective
 
         it "should add common package as dependency if present" do
           AgentDefinition.any_instance.expects(:common).returns("common")
-          PluginPackager.expects(:check_dir_present).times(3).returns(true)
+          PluginPackager.expects(:check_dir_present).times(2).returns(true)
           File.expects(:join).with("clientdir", "*").returns("clientdir/*")
-          File.expects(:join).with("bindir", "*").returns("bindir/*")
-          File.expects(:join).with("agentdir", "*.ddl").returns("agentdir/*.ddl")
+          File.expects(:join).with("aggregatedir", "*").returns("aggregatedir/*")
           Dir.expects(:glob).with("clientdir/*").returns(["client.rb"])
-          Dir.expects(:glob).with("bindir/*").returns(["bin.rb"])
-          Dir.expects(:glob).with("agentdir/*.ddl").returns(["agent.ddl"])
+          Dir.expects(:glob).with("aggregatedir/*").returns(["aggregate.rb"])
 
           client = AgentDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "agent")
-          client.packagedata[:client][:dependencies].should == ["mcollective-client", "mcollective-foo-common"]
+          client.packagedata[:client][:dependencies].should == [{:name => "mcollective-common", :version => nil},
+                                                                {:name => "mcollective-foo-common", :version => 1}]
         end
       end
     end