mcollective-test 0.1.4 → 0.2.0

data/lib/mcollective/test/application_test.rb

@@ -1,43 +1,43 @@
 module MCollective
-    module Test
-        class ApplicationTest
-            attr_reader :config, :logger, :application, :plugin
+  module Test
+    class ApplicationTest
+      attr_reader :config, :logger, :application, :plugin
 
-            include Test::Util
+      include Test::Util
 
-            def initialize(application, options={})
-                config = options[:config] || {}
-                facts = options[:facts] || {"fact" => "value"}
+      def initialize(application, options={})
+        config = options[:config] || {}
+        facts = options[:facts] || {"fact" => "value"}
 
-                ARGV.clear
+        ARGV.clear
 
-                @config = create_config_mock(config)
-                @application = application.to_s
-                @logger = create_logger_mock
-                @plugin = load_application(@application, options[:application_file])
+        @config = create_config_mock(config)
+        @application = application.to_s
+        @logger = create_logger_mock
+        @plugin = load_application(@application, options[:application_file])
 
-                @plugin.stubs(:printrpcstats)
-                @plugin.stubs(:puts)
-                @plugin.stubs(:printf)
+        @plugin.stubs(:printrpcstats)
+        @plugin.stubs(:puts)
+        @plugin.stubs(:printf)
 
-                make_create_client
-            end
+        make_create_client
+      end
 
-            def make_create_client
-                @plugin.instance_eval "
-                    def create_client(client)
-                        mock_client = Mocha::Mock.new
-                        mock_client.stubs(:progress=)
-                        mock_client.stubs(:progress)
+      def make_create_client
+        @plugin.instance_eval "
+          def create_client(client)
+              mock_client = Mocha::Mock.new
+              mock_client.stubs(:progress=)
+              mock_client.stubs(:progress)
 
-                        yield(mock_client) if block_given?
+              yield(mock_client) if block_given?
 
-                        MCollective::Application::Facts.any_instance.expects(:rpcclient).with(client).returns(mock_client)
+              MCollective::Application::Facts.any_instance.expects(:rpcclient).with(client).returns(mock_client)
 
-                        mock_client
-                    end
-                "
-            end
-        end
+              mock_client
+          end
+        "
+      end
     end
+  end
 end

data/lib/mcollective/test/local_agent_test.rb

@@ -1,44 +1,45 @@
 module MCollective
-    module Test
-        class LocalAgentTest
-            attr_reader :config, :logger, :agent, :connector, :plugin, :facts
-
-            include Test::Util
-
-            def initialize(agent, options={})
-                config = options[:config]
-                facts = options[:facts] || {"fact" => "value"}
-
-                @config = create_config_mock(config)
-                @agent = agent.to_s
-                @logger = create_logger_mock
-                @connector = create_connector_mock
-                @plugin = load_agent(agent, options[:agent_file])
-
-                create_facts_mock(facts)
-
-                make_call_helper
-            end
-
-
-            # Place the mocked connector into the plugin instance and
-            # create a call helper method that passes the connector in
-            # and call the action via handlemsg.
-            #
-            # This will let you test auditing etc
-            def make_call_helper
-                @plugin.instance_variable_set("@mocked_connector", @connector)
-
-                @plugin.instance_eval "
-                    def call(action, args={})
-                        request = {:action => action.to_s,
-                                   :agent => '#{@agent}',
-                                   :data => args}
-
-                        handlemsg({:body => request}, @mocked_connector)
-                    end
-                "
-            end
-        end
+  module Test
+    class LocalAgentTest
+      attr_reader :config, :logger, :agent, :connector, :plugin, :facts
+
+      include Test::Util
+
+      def initialize(agent, options={})
+        config = options[:config]
+        facts = options[:facts] || {"fact" => "value"}
+
+        @config = create_config_mock(config)
+        @agent = agent.to_s
+        @logger = create_logger_mock
+        @connector = create_connector_mock
+        @plugin = load_agent(agent, options[:agent_file])
+
+        create_facts_mock(facts)
+        mock_validators
+
+        make_call_helper
+      end
+
+
+      # Place the mocked connector into the plugin instance and
+      # create a call helper method that passes the connector in
+      # and call the action via handlemsg.
+      #
+      # This will let you test auditing etc
+      def make_call_helper
+        @plugin.instance_variable_set("@mocked_connector", @connector)
+
+        @plugin.instance_eval "
+          def call(action, args={})
+              request = {:action => action.to_s,
+                         :agent => '#{@agent}',
+                         :data => args}
+
+              handlemsg({:body => request}, @mocked_connector)
+          end
+        "
+      end
     end
+  end
 end

data/lib/mcollective/test/matchers/application_description.rb

@@ -1,39 +1,39 @@
 module MCollective
-    module Test
-        module Matchers
-            def have_a_description(description=nil); ApplicationDescription.new(description); end
+  module Test
+    module Matchers
+      def have_a_description(description=nil); ApplicationDescription.new(description); end
 
-            class ApplicationDescription
-                def initialize(match=nil)
-                    @match = match
-                end
+      class ApplicationDescription
+        def initialize(match=nil)
+          @match = match
+        end
 
-                def matches?(actual)
-                    @actual = actual.application_description
+        def matches?(actual)
+          @actual = actual.application_description
 
-                    if @match
-                        return @actual == @match
-                    else
-                        return !@actual.nil?
-                    end
-                end
+          if @match
+            return @actual == @match
+          else
+            return !@actual.nil?
+          end
+        end
 
-                def failure_message
-                    if @match
-                        "application should have a description '#{@match}' but got '#{@actual}'"
-                    else
-                        "application should have a description, got #{@match}"
-                    end
-                end
+        def failure_message
+          if @match
+            "application should have a description '#{@match}' but got '#{@actual}'"
+          else
+            "application should have a description, got #{@match}"
+          end
+        end
 
-                def negative_failure_message
-                    if @match
-                        "application should not have a description matching '#{@match}' but got '#{@actual}'"
-                    else
-                        "application should not have a description"
-                    end
-                end
-            end
+        def negative_failure_message
+          if @match
+            "application should not have a description matching '#{@match}' but got '#{@actual}'"
+          else
+            "application should not have a description"
+          end
         end
+      end
     end
+  end
 end

data/lib/mcollective/test/matchers/rpc_metadata.rb

@@ -1,40 +1,40 @@
 module MCollective
-    module Test
-        module Matchers
-            def have_valid_metadata; RPCMetadata.new; end
+  module Test
+    module Matchers
+      def have_valid_metadata; RPCMetadata.new; end
 
-            class RPCMetadata
-                def matches?(actual)
-                    actual = actual.meta
+      class RPCMetadata
+        def matches?(actual)
+          actual = actual.meta
 
-                    @msg = "Unknown error"
+          @msg = "Unknown error"
 
-                    [:name, :description, :author, :license, :version, :url, :timeout].each do |item|
-                        unless actual.include?(item)
-                            @msg = "needs a '#{item}' item"
-                            return false
-                        end
-                    end
+          [:name, :description, :author, :license, :version, :url, :timeout].each do |item|
+            unless actual.include?(item)
+              @msg = "needs a '#{item}' item"
+              return false
+            end
+          end
 
-                    [:name, :description, :author, :license, :version, :url].each do |item|
-                        unless actual[item].is_a?(String)
-                            @msg = "#{item} should be a string"
-                            return false
-                        end
-                    end
+          [:name, :description, :author, :license, :version, :url].each do |item|
+            unless actual[item].is_a?(String)
+              @msg = "#{item} should be a string"
+              return false
+            end
+          end
 
-                    unless actual[:timeout].is_a?(Numeric)
-                        @msg = "timeout should be numeric"
-                        return false
-                    end
+          unless actual[:timeout].is_a?(Numeric)
+            @msg = "timeout should be numeric"
+            return false
+          end
 
-                    return true
-                end
+          return true
+        end
 
-                def failure_message
-                    "Invalid meta data: #{@msg}"
-                end
-            end
+        def failure_message
+          "Invalid meta data: #{@msg}"
         end
+      end
     end
+  end
 end

data/lib/mcollective/test/matchers/rpc_result_items.rb

@@ -1,102 +1,102 @@
 module MCollective
-    module Test
-        module Matchers
-            def have_data_items(*items); RPCResultItems.new(items);end
+  module Test
+    module Matchers
+      def have_data_items(*items); RPCResultItems.new(items);end
 
-            class RPCResultItems
-                def initialize(expected)
-                    @expected = expected
-                    @actual = []
-                end
+      class RPCResultItems
+        def initialize(expected)
+          @expected = expected
+          @actual = []
+        end
 
-                def matches?(actual)
-                    if actual == []
-                        return false
-                    end
+        def matches?(actual)
+          if actual == []
+            return false
+          end
 
-                    [actual].flatten.each do |result|
-                        result = result.results if result.is_a?(MCollective::RPC::Result)
-                        @nodeid = result[:data][:test_sender]
-                        @actual << result
-                        @expected.each do |e|
-                            if e.is_a? Hash
-                                e.keys.each do |k|
-                                    unless result[:data].keys.include?(k)
-                                        return false
-                                    end
-                                end
-                                e.keys.each do |k|
-                                    if e[k].is_a?(String) || e[k].is_a?(Regexp)
-                                        unless result[:data][k].match e[k]
-                                            return false
-                                        end
-                                    else
-                                        unless result[:data][k] == e[k]
-                                            return false
-                                        end
-                                    end
-                                end
-                            else
-                                unless result[:data].keys.include? e
-                                    return false
-                                end
-                            end
-                        end
-                    end
-                    true
+          [actual].flatten.each do |result|
+            result = result.results if result.is_a?(MCollective::RPC::Result)
+            @nodeid = result[:data][:test_sender]
+            @actual << result
+            @expected.each do |e|
+              if e.is_a? Hash
+                e.keys.each do |k|
+                  unless result[:data].keys.include?(k)
+                    return false
+                  end
                 end
-
-                def failure_message
-                    return_string = "Failure from #{@nodeid}\n"
-                    return_string << "Expected : \n"
-                    @expected.each do |e|
-                        if e.is_a? Hash
-                            e.keys.each do |k|
-                                return_string << " '#{k}' with value '#{e[k]}'\n"
-                            end
-                        else
-                            return_string << " '#{e}' to be present\n"
-                        end
+                e.keys.each do |k|
+                  if e[k].is_a?(String) || e[k].is_a?(Regexp)
+                    unless result[:data][k].match e[k]
+                      return false
                     end
-
-                    return_string << "Got : \n"
-                    @actual.each do |a|
-                        if a[:sender] == @nodeid
-                            a[:data].each do |data|
-                                return_string << " '#{data[0]}' with value '#{data[1]}'\n"
-                            end
-                        end
+                  else
+                    unless result[:data][k] == e[k]
+                      return false
                     end
-
-                    return_string
+                  end
+                end
+              else
+                unless result[:data].keys.include? e
+                  return false
                 end
+              end
+            end
+          end
+          true
+        end
 
-                def negative_failure_message
-                    return_string = "Failure from #{@nodeid}\n"
-                    return_string << "Did not expect : \n"
-                    @expected.each do |e|
-                        if e.is_a? Hash
-                            e.keys.each do |k|
-                                return_string << " '#{k}' with value '#{e[k]}'\n"
-                            end
-                        else
-                            return_string << " '#{e}' to not be present\n"
-                        end
-                    end
+        def failure_message
+          return_string = "Failure from #{@nodeid}\n"
+          return_string << "Expected : \n"
+          @expected.each do |e|
+            if e.is_a? Hash
+              e.keys.each do |k|
+                return_string << " '#{k}' with value '#{e[k]}'\n"
+              end
+            else
+              return_string << " '#{e}' to be present\n"
+            end
+          end
 
-                    return_string << "But got : \n"
-                    @actual.each do |a|
-                        if a[:sender] == @nodeid
-                            a[:data].each do |data|
-                                return_string << " '#{data[0]}' with value '#{data[1]}'\n"
-                            end
-                        end
-                    end
+          return_string << "Got : \n"
+          @actual.each do |a|
+            if a[:sender] == @nodeid
+              a[:data].each do |data|
+                return_string << " '#{data[0]}' with value '#{data[1]}'\n"
+              end
+            end
+          end
 
-                    return_string
-                end
+          return_string
+        end
+
+        def negative_failure_message
+          return_string = "Failure from #{@nodeid}\n"
+          return_string << "Did not expect : \n"
+          @expected.each do |e|
+            if e.is_a? Hash
+              e.keys.each do |k|
+                return_string << " '#{k}' with value '#{e[k]}'\n"
+              end
+            else
+              return_string << " '#{e}' to not be present\n"
+            end
+          end
 
+          return_string << "But got : \n"
+          @actual.each do |a|
+            if a[:sender] == @nodeid
+              a[:data].each do |data|
+                return_string << " '#{data[0]}' with value '#{data[1]}'\n"
+              end
             end
+          end
+
+          return_string
         end
+
+      end
     end
+  end
 end

data/lib/mcollective/test/matchers/rpc_status.rb

@@ -1,48 +1,48 @@
 module MCollective
-    module Test
-        module Matchers
-            def rpc_success; RPCStatus.new(0); end
-            def rpc_aborted; RPCStatus.new(1); end
-            def rpc_unknown_action; RPCStatus.new(2); end
-            def rpc_missing_data; RPCStatus.new(3); end
-            def rpc_invalid_data; RPCStatus.new(4); end
-            def rpc_unknown; RPCStatus.new(5); end
+  module Test
+    module Matchers
+      def rpc_success; RPCStatus.new(0); end
+      def rpc_aborted; RPCStatus.new(1); end
+      def rpc_unknown_action; RPCStatus.new(2); end
+      def rpc_missing_data; RPCStatus.new(3); end
+      def rpc_invalid_data; RPCStatus.new(4); end
+      def rpc_unknown; RPCStatus.new(5); end
 
-            alias be_successful rpc_success
-            alias be_aborted_error rpc_aborted
-            alias be_unknown_action_error rpc_unknown_action
-            alias be_missing_data_error rpc_missing_data
-            alias be_invalid_data_error rpc_invalid_data
-            alias be_unknown_error rpc_unknown
+      alias be_successful rpc_success
+      alias be_aborted_error rpc_aborted
+      alias be_unknown_action_error rpc_unknown_action
+      alias be_missing_data_error rpc_missing_data
+      alias be_invalid_data_error rpc_invalid_data
+      alias be_unknown_error rpc_unknown
 
-            class RPCStatus
-                def initialize(code)
-                    @code = code
-                end
+      class RPCStatus
+        def initialize(code)
+          @code = code
+        end
 
-                def matches?(actual)
-                    if actual == []
-                        return false
-                    end
-                    [actual].flatten.each do |result|
-                        result = result.results if result.is_a?(MCollective::RPC::Result)
+        def matches?(actual)
+          if actual == []
+            return false
+          end
+          [actual].flatten.each do |result|
+            result = result.results if result.is_a?(MCollective::RPC::Result)
 
-                        @actual = result[:statuscode]
+            @actual = result[:statuscode]
 
-                        unless @actual == @code
-                            return false
-                        end
-                    end
-                end
+            unless @actual == @code
+              return false
+            end
+          end
+        end
 
-                def failure_message
-                    "expected :statuscode == #{@code} but got '#{@actual}'"
-                end
+        def failure_message
+          "expected :statuscode == #{@code} but got '#{@actual}'"
+        end
 
-                def negative_failure_message
-                    "expected :statucode != #{@code} but got '#{@actual}'"
-                end
-            end
+        def negative_failure_message
+          "expected :statucode != #{@code} but got '#{@actual}'"
         end
+      end
     end
+  end
 end

data/lib/mcollective/test/matchers.rb

@@ -1,10 +1,10 @@
 module MCollective
-    module Test
-        module Matchers
-            require 'mcollective/test/matchers/rpc_result_items.rb'
-            require 'mcollective/test/matchers/rpc_metadata.rb'
-            require 'mcollective/test/matchers/rpc_status.rb'
-            require 'mcollective/test/matchers/application_description.rb'
-        end
+  module Test
+    module Matchers
+      require 'mcollective/test/matchers/rpc_result_items.rb'
+      require 'mcollective/test/matchers/rpc_metadata.rb'
+      require 'mcollective/test/matchers/rpc_status.rb'
+      require 'mcollective/test/matchers/application_description.rb'
     end
+  end
 end

data/lib/mcollective/test/remote_agent_test.rb

@@ -1,15 +1,15 @@
 module MCollective
-    module Test
-        class RemoteAgentTest
-            attr_reader :agent, :plugin
+  module Test
+    class RemoteAgentTest
+      attr_reader :agent, :plugin
 
-            include MCollective::RPC
+      include MCollective::RPC
 
-            def initialize(agent)
-                @agent = agent.to_s
-                @plugin = rpcclient(agent)
-                @plugin.progress = false
-            end
-        end
+      def initialize(agent)
+        @agent = agent.to_s
+        @plugin = rpcclient(agent)
+        @plugin.progress = false
+      end
     end
+  end
 end

data/lib/mcollective/test/util.rb

@@ -1,112 +1,123 @@
 module MCollective
-    module Test
-        module Util
-            def create_facts_mock(factsource)
-                facts = Mocha::Mock.new('facts')
-                facts.stubs(:get_facts).returns(factsource)
-
-                factsource.each_pair do |k, v|
-                    facts.stubs(:get_fact).with(k).returns(v)
-                end
+  module Test
+    module Util
+      def create_facts_mock(factsource)
+        facts = Mocha::Mock.new('facts')
+        facts.stubs(:get_facts).returns(factsource)
+
+        factsource.each_pair do |k, v|
+          facts.stubs(:get_fact).with(k).returns(v)
+        end
 
-                MCollective::PluginManager << {:type => "facts_plugin", :class => facts, :single_instance => false}
+        MCollective::PluginManager << {:type => "facts_plugin", :class => facts, :single_instance => false}
+      end
+
+      def create_config_mock(config)
+        cfg = Mocha::Mock.new('config')
+        cfg.stubs(:configured).returns(true)
+        cfg.stubs(:rpcauthorization).returns(false)
+        cfg.stubs(:main_collective).returns("mcollective")
+        cfg.stubs(:collectives).returns(["production", "staging"])
+        cfg.stubs(:classesfile).returns("classes.txt")
+        cfg.stubs(:identity).returns("rspec_tests")
+        cfg.stubs(:logger_type).returns("console")
+        cfg.stubs(:loglevel).returns("error")
+
+        if config
+          config.each_pair do |k, v|
+            cfg.send(:stubs, k).returns(v)
+          end
+
+          if config.include?(:libdir)
+            [config[:libdir]].flatten.each do |dir|
+              $: << dir if File.exist?(dir)
             end
 
-            def create_config_mock(config)
-                cfg = Mocha::Mock.new('config')
-                cfg.stubs(:configured).returns(true)
-                cfg.stubs(:rpcauthorization).returns(false)
-                cfg.stubs(:main_collective).returns("mcollective")
-                cfg.stubs(:collectives).returns(["production", "staging"])
-                cfg.stubs(:classesfile).returns("classes.txt")
-                cfg.stubs(:identity).returns("rspec_tests")
-
-                if config
-                    config.each_pair do |k, v|
-                        cfg.send(:stubs, k).returns(v)
-                    end
-
-                    if config.include?(:libdir)
-                        [config[:libdir]].flatten.each do |dir|
-                            $: << dir if File.exist?(dir)
-                        end
-                    end
-                end
-
-                MCollective::Config.stubs(:instance).returns(cfg)
-
-                cfg
-            end
+            cfg.stubs(:libdir).returns(config[:libdir])
+          end
+        end
 
-            def create_logger_mock
-                logger = Mocha::Mock.new(:logger)
+        MCollective::Config.stubs(:instance).returns(cfg)
 
-                [:log, :start, :debug, :info, :warn].each do |meth|
-                    logger.stubs(meth)
-                end
+        cfg
+      end
 
-                MCollective::Log.configure(logger)
+      def mock_validators
+        MCollective::Validator.stubs(:load_validators)
+        MCollective::Validator.stubs(:validate).returns(true)
+      end
 
-                logger
-            end
+      def create_logger_mock
+        logger = Mocha::Mock.new(:logger)
+
+        [:log, :start, :debug, :info, :warn].each do |meth|
+          logger.stubs(meth)
+        end
 
-            def create_connector_mock
-                connector = Mocha::Mock.new(:connector)
+        MCollective::Log.configure(logger)
 
-                [:connect, :receive, :publish, :subscribe, :unsubscribe, :disconnect].each do |meth|
-                    connector.stubs(meth)
-                end
+        logger
+      end
 
-                MCollective::PluginManager << {:type => "connector_plugin", :class => connector}
+      def create_connector_mock
+        connector = Mocha::Mock.new(:connector)
 
-                connector
-            end
+        [:connect, :receive, :publish, :subscribe, :unsubscribe, :disconnect].each do |meth|
+          connector.stubs(meth)
+        end
 
-            def load_application(application, application_file=nil)
-                classname = "MCollective::Application::#{application.capitalize}"
-                MCollective::PluginManager.delete("#{application}_application")
+        MCollective::PluginManager << {:type => "connector_plugin", :class => connector}
 
-                if application_file
-                    raise "Cannot find application file #{application_file} for application #{application}" unless File.exist?(application_file)
-                    load application_file
-                else
-                    MCollective::PluginManager.loadclass(classname)
-                end
+        connector
+      end
 
+      def load_application(application, application_file=nil)
+        classname = "MCollective::Application::#{application.capitalize}"
+        MCollective::PluginManager.delete("#{application}_application")
 
-                MCollective::PluginManager << {:type => "#{application}_application", :class => classname, :single_instance => false}
-                MCollective::PluginManager["#{application}_application"]
-            end
+        if application_file
+          raise "Cannot find application file #{application_file} for application #{application}" unless File.exist?(application_file)
+          load application_file
+        else
+          MCollective::PluginManager.loadclass(classname)
+        end
+
+        MCollective::PluginManager << {:type => "#{application}_application", :class => classname, :single_instance => false}
+        MCollective::PluginManager["#{application}_application"]
+      end
 
-            def load_agent(agent, agent_file=nil)
-                classname = "MCollective::Agent::#{agent.capitalize}"
+      def load_agent(agent, agent_file=nil)
+        classname = "MCollective::Agent::#{agent.capitalize}"
 
-                MCollective::PluginManager.delete("#{agent}_agent")
+        MCollective::PluginManager.delete("#{agent}_agent")
 
-                if agent_file
-                    raise "Cannot find agent file #{agent_file} for agent #{agent}" unless File.exist?(agent_file)
-                    load agent_file
-                else
-                    MCollective::PluginManager.loadclass(classname)
-                end
+        if agent_file
+          raise "Cannot find agent file #{agent_file} for agent #{agent}" unless File.exist?(agent_file)
+          load agent_file
+        else
+          MCollective::PluginManager.loadclass(classname)
+        end
 
-                # Stub out startup_hook as this feature should probably
-                # be deprecated and it's really hard to test
+        # Stub out startup_hook as this feature should probably
+        # be deprecated and it's really hard to test
 
-                klass = MCollective::Agent.const_get(agent.capitalize)
-                klass.any_instance.stubs(:startup_hook).returns(true)
+        klass = MCollective::Agent.const_get(agent.capitalize)
 
-                MCollective::PluginManager << {:type => "#{agent}_agent", :class => classname, :single_instance => false}
-                MCollective::PluginManager["#{agent}_agent"]
-            end
+        klass.any_instance.stubs("load_ddl").returns(true)
+        klass.any_instance.stubs(:startup_hook).returns(true)
+        MCollective::RPC::Request.any_instance.stubs(:validate!).returns(true)
 
-            def create_response(senderid, data = {}, stats = nil , statuscode = 0, statusmsg = "OK")
-                unless stats == nil
-                    {:senderid => senderid, :body =>{:data => data, :stats => stats}}
-                else
-                    {:senderid => senderid, :body =>{:data => data}}
-                end
-            end
+        MCollective::PluginManager << {:type => "#{agent}_agent", :class => classname, :single_instance => false}
+        MCollective::PluginManager["#{agent}_agent"]
+      end
+
+      def create_response(senderid, data = {}, stats = nil , statuscode = 0, statusmsg = "OK")
+        unless stats == nil
+          {:senderid => senderid, :body =>{:data => data, :stats => stats}}
+        else
+          {:senderid => senderid, :body =>{:data => data}}
         end
+      end
     end
+  end
 end

data/lib/mcollective/test.rb

@@ -1,9 +1,9 @@
 module MCollective
-    module Test
-        autoload :Util, "mcollective/test/util"
-        autoload :Matchers, "mcollective/test/matchers"
-        autoload :LocalAgentTest, "mcollective/test/local_agent_test.rb"
-        autoload :RemoteAgentTest, "mcollective/test/remote_agent_test.rb"
-        autoload :ApplicationTest, "mcollective/test/application_test.rb"
-    end
+  module Test
+    autoload :Util, "mcollective/test/util"
+    autoload :Matchers, "mcollective/test/matchers"
+    autoload :LocalAgentTest, "mcollective/test/local_agent_test.rb"
+    autoload :RemoteAgentTest, "mcollective/test/remote_agent_test.rb"
+    autoload :ApplicationTest, "mcollective/test/application_test.rb"
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mcollective-test
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 4
-  version: 0.1.4
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - R.I.Pienaar
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-21 00:00:00 +00:00
+date: 2012-09-14 00:00:00 +01:00
 default_executable: 
 dependencies: []