mcollective-test 0.1.2

data/lib/mcollective/test.rb

@@ -0,0 +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
+end

data/lib/mcollective/test/application_test.rb

@@ -0,0 +1,43 @@
+module MCollective
+    module Test
+        class ApplicationTest
+            attr_reader :config, :logger, :application, :plugin
+
+            include Test::Util
+
+            def initialize(application, options={})
+                config = options[:config] || {}
+                facts = options[:facts] || {"fact" => "value"}
+
+                ARGV.clear
+
+                @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)
+
+                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)
+
+                        yield(mock_client) if block_given?
+
+                        MCollective::Application::Facts.any_instance.expects(:rpcclient).with(client).returns(mock_client)
+
+                        mock_client
+                    end
+                "
+            end
+        end
+    end
+end

data/lib/mcollective/test/local_agent_test.rb

@@ -0,0 +1,44 @@
+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
+    end
+end

data/lib/mcollective/test/matchers.rb

@@ -0,0 +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
+    end
+end

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

@@ -0,0 +1,39 @@
+module MCollective
+    module Test
+        module Matchers
+            def have_a_description(description=nil); ApplicationDescription.new(description); end
+
+            class ApplicationDescription
+                def initialize(match=nil)
+                    @match = match
+                end
+
+                def matches?(actual)
+                    @actual = actual.application_description
+
+                    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 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

@@ -0,0 +1,40 @@
+module MCollective
+    module Test
+        module Matchers
+            def have_valid_metadata; RPCMetadata.new; end
+
+            class RPCMetadata
+                def matches?(actual)
+                    actual = actual.meta
+
+                    @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].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
+
+                    return true
+                end
+
+                def failure_message
+                    "Invalid meta data: #{@msg}"
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,35 @@
+module MCollective
+    module Test
+        module Matchers
+            def have_data_items(*items); RPCResultItems.new(items); end
+
+            class RPCResultItems
+                def initialize(expected)
+                    @expected = expected.flatten.sort
+                end
+
+                def matches?(actual)
+                    [actual].flatten.each do |result|
+                        result = result.results if result.is_a?(MCollective::RPC::Result)
+
+                        @actual = result[:data].keys.sort
+
+                        unless @actual == @expected
+                            return false
+                        end
+                    end
+
+                    true
+                end
+
+                def failure_message
+                    "expected keys '#{@expected.join ', '}' but got '#{@actual.join ', '}'"
+                end
+
+                def negative_failure_message
+                    "did not expect keys '#{@expected.join ', '}' but got '#{@actual.keys.join ', '}'"
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,45 @@
+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
+
+            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
+
+                def matches?(actual)
+                    [actual].flatten.each do |result|
+                        result = result.results if result.is_a?(MCollective::RPC::Result)
+
+                        @actual = result[:statuscode]
+
+                        unless @actual == @code
+                            return false
+                        end
+                    end
+                end
+
+                def failure_message
+                    "expected :statuscode == #{@code} but got '#{@actual}'"
+                end
+
+                def negative_failure_message
+                    "expected :statucode != #{@code} but got '#{@actual}'"
+                end
+            end
+        end
+    end
+end

data/lib/mcollective/test/remote_agent_test.rb

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

data/lib/mcollective/test/util.rb

@@ -0,0 +1,109 @@
+module MCollective
+    module Test
+        module Util
+            def create_facts_mock(factsource)
+                facts = Mocha::Mock.new
+                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}
+            end
+
+            def create_config_mock(config)
+                cfg = Mocha::Mock.new
+                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
+
+            def create_logger_mock
+                logger = Mocha::Mock.new(:logger)
+
+                [:log, :start, :debug, :info, :warn].each do |meth|
+                    logger.stubs(meth)
+                end
+
+                MCollective::Log.configure(logger)
+
+                logger
+            end
+
+            def create_connector_mock
+                connector = Mocha::Mock.new(:connector)
+
+                [:connect, :receive, :publish, :subscribe, :unsubscribe, :disconnect].each do |meth|
+                    connector.stubs(meth)
+                end
+
+                MCollective::PluginManager << {:type => "connector_plugin", :class => connector}
+
+                connector
+            end
+
+            def load_application(application, application_file=nil)
+                classname = "MCollective::Application::#{application.capitalize}"
+                MCollective::PluginManager.delete("#{application}_application")
+
+                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.loadclass(classname)
+
+                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}"
+
+                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
+
+                # 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)
+
+                MCollective::PluginManager << {:type => "#{agent}_agent", :class => classname, :single_instance => false}
+                MCollective::PluginManager["#{agent}_agent"]
+            end
+
+            def create_response(senderid, data = {}, statuscode = 0, statusmsg = "OK")
+                {:senderid => senderid, :body =>{:data => data}}
+            end
+        end
+    end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: mcollective-test
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- R.I.Pienaar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-21 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Helpers, matchers and other utilities for writing agent, application and integration tests
+email: rip@devco.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/mcollective/test/matchers/rpc_result_items.rb
+- lib/mcollective/test/matchers/rpc_metadata.rb
+- lib/mcollective/test/matchers/application_description.rb
+- lib/mcollective/test/matchers/rpc_status.rb
+- lib/mcollective/test/local_agent_test.rb
+- lib/mcollective/test/matchers.rb
+- lib/mcollective/test/application_test.rb
+- lib/mcollective/test/remote_agent_test.rb
+- lib/mcollective/test/util.rb
+- lib/mcollective/test.rb
+has_rdoc: true
+homepage: https://github.com/ripienaar/mcollective-test/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Test helper for MCollective
+test_files: []
+