mcollective-client 1.3.3

data/spec/unit/pluginmanager_spec.rb

@@ -0,0 +1,173 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe PluginManager do
+    before do
+      class MCollective::Foo; end
+
+      PluginManager.pluginlist.each {|p| PluginManager.delete p}
+    end
+
+    describe "#<<" do
+      it "should store a plugin by name" do
+        PluginManager << {:type => "foo", :class => "MCollective::Foo"}
+        PluginManager.instance_variable_get("@plugins").include?("foo").should == true
+      end
+
+      it "should store a plugin instance" do
+        f = MCollective::Foo.new
+
+        PluginManager << {:type => "foo", :class => f}
+        PluginManager.instance_variable_get("@plugins")["foo"][:instance].object_id.should == f.object_id
+      end
+
+      it "should detect duplicate plugins" do
+        PluginManager << {:type => "foo", :class => "MCollective::Foo"}
+
+        expect {
+          PluginManager << {:type => "foo", :class => "MCollective::Foo"}
+        }.to raise_error("Plugin foo already loaded")
+      end
+
+      it "should store single instance preference correctly" do
+        PluginManager << {:type => "foo", :class => "MCollective::Foo", :single_instance => false}
+        PluginManager.instance_variable_get("@plugins")["foo"][:single].should == false
+      end
+
+      it "should always set single to true when supplied an instance" do
+        PluginManager << {:type => "foo", :class => MCollective::Foo.new, :single_instance => false}
+        PluginManager.instance_variable_get("@plugins")["foo"][:single].should == true
+      end
+    end
+
+    describe "#delete" do
+      it "should remove plugins" do
+        PluginManager << {:type => "foo", :class => MCollective::Foo.new}
+        PluginManager.instance_variable_get("@plugins").include?("foo").should == true
+        PluginManager.delete("foo")
+        PluginManager.instance_variable_get("@plugins").include?("foo").should == false
+      end
+    end
+
+    describe "#include?" do
+      it "should correctly check if plugins were added" do
+        PluginManager << {:type => "foo", :class => MCollective::Foo.new}
+        PluginManager.include?("foo").should == true
+        PluginManager.include?("bar").should == false
+      end
+    end
+
+    describe "#pluginlist" do
+      it "should return the correct list of plugins" do
+        PluginManager << {:type => "foo", :class => MCollective::Foo.new}
+        PluginManager << {:type => "bar", :class => MCollective::Foo.new}
+
+        PluginManager.pluginlist.sort.should == ["bar", "foo"]
+      end
+    end
+
+    describe "#[]" do
+      it "should detect if the requested plugin does not exist" do
+        expect {
+          PluginManager["foo"]
+        }.to raise_error("No plugin foo defined")
+      end
+
+      it "should create new instances on demand" do
+        PluginManager << {:type => "foo", :class => "MCollective::Foo"}
+        PluginManager["foo"].class.should == MCollective::Foo
+      end
+
+      it "should return the cached instance" do
+        f = MCollective::Foo.new
+
+        PluginManager << {:type => "foo", :class => f}
+        PluginManager["foo"].object_id.should == f.object_id
+      end
+
+      it "should create new instances on every request if requested" do
+        PluginManager << {:type => "foo", :class => "MCollective::Foo", :single_instance => false}
+        PluginManager["foo"].object_id.should_not == PluginManager["foo"].object_id
+      end
+    end
+
+    describe "#find" do
+      before do
+        @config.stubs(:libdir).returns(["/libdir/"])
+        Config.stubs(:instance).returns(@config)
+      end
+
+      it "should find all plugins in configured libdirs" do
+        File.expects(:join).with(["/libdir/", "mcollective", "test"]).returns("/plugindir/")
+        File.expects(:directory?).with("/plugindir/").returns(true)
+        Dir.expects(:new).with("/plugindir/").returns(["plugin.rb"])
+        PluginManager.find("test").should == ["plugin"]
+      end
+
+      it "should find all plugins with a given file extension" do
+        File.expects(:join).with(["/libdir/", "mcollective", "test"]).returns("/plugindir/")
+        File.expects(:directory?).with("/plugindir/").returns(true)
+        Dir.expects(:new).with("/plugindir/").returns(["plugin.ddl"])
+        PluginManager.find("test", "ddl").should == ["plugin"]
+      end
+
+      it "should skip libdirs that do not have the plugin type directories" do
+        @config.stubs(:libdir).returns(["/plugindir/", "/tmp/"])
+        File.expects(:join).with(["/plugindir/", "mcollective", "test"]).returns("/plugindir/")
+        File.expects(:join).with(["/tmp/", "mcollective", "test"]).returns("/tmpdir/")
+        File.expects(:directory?).with("/plugindir/").returns(true)
+        File.expects(:directory?).with("/tmpdir/").returns(false)
+        Dir.expects(:new).with("/plugindir/").returns(["plugin.ddl"])
+        PluginManager.find("test", "ddl").should == ["plugin"]
+      end
+    end
+
+    describe "#find_and_load" do
+      before do
+        @config.stubs(:libdir).returns(["/libdir/"])
+        Config.stubs(:instance).returns(@config)
+        PluginManager.expects(:loadclass).with("MCollective::Test::Testplugin", true)
+      end
+
+      it "should find and load all plugins from all libdirs that match the type" do
+        PluginManager.expects(:find).with("test", ".rb").returns(["testplugin"])
+        PluginManager.find_and_load("test")
+      end
+
+      it "should exclude plugins who do not match criteria if block is given" do
+        PluginManager.expects(:find).with("test", ".rb").returns(["testplugin", "failplugin"])
+        PluginManager.find_and_load("test") {|plugin| plugin.match(/^test/)}
+      end
+    end
+
+    describe "#loadclass" do
+      it "should load the correct filename given a ruby class name" do
+        PluginManager.stubs(:load).with("mcollective/foo.rb").once
+        PluginManager.loadclass("MCollective::Foo")
+      end
+
+      it "should raise errors for load errors" do
+        PluginManager.stubs(:load).raises("load failure")
+        Log.expects(:error)
+        expect { PluginManager.loadclass("foo") }.to raise_error(/load failure/)
+      end
+
+      it "should support squashing load errors" do
+        PluginManager.stubs(:load).raises("load failure")
+        Log.expects(:error)
+        PluginManager.loadclass("foo", true)
+      end
+    end
+
+    describe "#grep" do
+      it "should return matching plugins from the list" do
+        PluginManager << {:type => "foo", :class => MCollective::Foo.new}
+        PluginManager << {:type => "bar", :class => MCollective::Foo.new}
+
+        PluginManager.grep(/oo/).should == ["foo"]
+      end
+    end
+  end
+end

data/spec/unit/pluginpackager/agent_definition_spec.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module PluginPackager
+    describe AgentDefinition do
+      before :each do
+        PluginPackager.expects(:get_metadata).once.returns({:name => "foo"})
+      end
+
+      it "should replace spaces in the package name with underscores" do
+        agent = AgentDefinition.new(".", "test package", nil, nil, nil, "agent")
+        agent.metadata[:name].should == "test_package"
+      end
+
+      describe "#identify_packages" do
+        it "should attempt to identify all agent packages" do
+          AgentDefinition.any_instance.expects(:common).once.returns(:check)
+          AgentDefinition.any_instance.expects(:agent).once.returns(:check)
+          AgentDefinition.any_instance.expects(:client).once.returns(:check)
+
+          agent = AgentDefinition.new(".", nil, nil, nil, nil, "agent")
+          agent.packagedata[:common].should == :check
+          agent.packagedata[:agent].should == :check
+          agent.packagedata[:client].should == :check
+        end
+      end
+
+      describe "#agent" do
+        before do
+          AgentDefinition.any_instance.expects(:client).once
+        end
+
+        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, "agent")
+          agent.packagedata[:agent].should == nil
+        end
+
+        it "should populate the agent files if the agent directory is present and not empty" 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"])
+
+          agent = AgentDefinition.new(".", nil, nil, nil, nil, "agent")
+          agent.packagedata[:agent][:files].should == ["file.rb", "implementation.rb"]
+        end
+
+        it "should add common package as dependency if present" do
+          AgentDefinition.any_instance.expects(:common).returns(true)
+          PluginPackager.expects(:check_dir_present).returns(true)
+          File.stubs(:join).returns("tmpdir")
+          Dir.stubs(:glob).returns([])
+
+          agent = AgentDefinition.new(".", nil, nil, nil, nil, "agent")
+          agent.packagedata[:agent][:dependencies].should == ["mcollective", "mcollective-foo-common"]
+        end
+      end
+
+      describe "#common" do
+        before do
+          AgentDefinition.any_instance.expects(:agent)
+          AgentDefinition.any_instance.expects(:client)
+        end
+
+        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, "agent")
+          common.packagedata[:common].should == nil
+        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, "agent")
+          common.packagedata[:common][:files].should == ["file.rb"]
+        end
+      end
+
+      describe "#client" do
+        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")
+        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)
+          File.expects(:join).with("clientdir", "*").returns("clientdir/*")
+          File.expects(:join).with("bindir", "*").returns("bindir/*")
+          File.expects(:join).with("agentdir", "*.ddl").returns("agentdir/*.ddl")
+          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"])
+
+          client = AgentDefinition.new(".", nil, nil, nil, nil, "agent")
+          client.packagedata[:client][:files].should == ["client.rb", "bin.rb", "agent.ddl"]
+        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)
+
+          client = AgentDefinition.new(".", nil, nil, nil, nil, "agent")
+          client.packagedata[:client].should == nil
+        end
+
+        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)
+          File.expects(:join).with("clientdir", "*").returns("clientdir/*")
+          File.expects(:join).with("bindir", "*").returns("bindir/*")
+          File.expects(:join).with("agentdir", "*.ddl").returns("agentdir/*.ddl")
+          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"])
+
+          client = AgentDefinition.new(".", nil, nil, nil, nil, "agent")
+          client.packagedata[:client][:dependencies].should == ["mcollective-client", "mcollective-foo-common"]
+        end
+      end
+    end
+  end
+end

data/spec/unit/pluginpackager/standard_definition_spec.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module PluginPackager
+    describe StandardDefinition do
+      before :each do
+        PluginPackager.expects(:get_metadata).once.returns({:name => "foo"})
+      end
+
+      it "should replace spaces in the package name with underscores" do
+        plugin = StandardDefinition.new(".", "test plugin", nil, nil, nil, :fooplugin)
+        plugin.metadata[:name].should == "test_plugin"
+      end
+
+      describe "#identify_packages" do
+        it "should attempt to identify all packages" do
+          StandardDefinition.any_instance.expects(:common).once.returns(:check)
+          StandardDefinition.any_instance.expects(:plugin).once.returns(:check)
+
+          plugin = StandardDefinition.new(".", nil, nil, nil, nil, :fooplugin)
+          plugin.packagedata[:common].should == :check
+          plugin.packagedata[:fooplugin].should == :check
+        end
+      end
+
+      describe "#plugin" do
+
+        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, :fooplugin)
+          plugin.packagedata[:fooplugin].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("./fooplugin/*").returns(["file.rb"])
+          plugin = StandardDefinition.new(".", nil, nil, nil, nil, :fooplugin)
+          plugin.packagedata[:fooplugin][:files].should == ["file.rb"]
+        end
+
+        it "should add common package as dependency if present" do
+          StandardDefinition.any_instance.expects(:common).returns(true)
+          PluginPackager.expects(:check_dir_present).returns(true)
+          Dir.expects(:glob).with("./fooplugin/*").returns(["file.rb"])
+          plugin = StandardDefinition.new(".", nil, nil, nil, nil, :fooplugin)
+          plugin.packagedata[:fooplugin][:files].should == ["file.rb"]
+          plugin.packagedata[:fooplugin][:dependencies].should == ["mcollective", "mcollective-foo-common"]
+        end
+      end
+
+      describe "#common" do
+        before do
+          StandardDefinition.any_instance.expects(:plugin).returns(false)
+        end
+
+        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, :fooplugin)
+          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, :fooplugin)
+          plugin.packagedata[:common][:files].should == ["common.rb"]
+        end
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/connector/activemq_spec.rb

@@ -0,0 +1,533 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+MCollective::PluginManager.clear
+
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/connector/activemq.rb'
+
+# create the stomp error class here as it does not always exist
+# all versions of the stomp gem and we do not want to tie tests
+# to the stomp gem
+module Stomp
+  module Error
+    class DuplicateSubscription < RuntimeError; end
+  end
+end
+
+module MCollective
+  module Connector
+    describe Activemq do
+      before do
+        unless ::Stomp::Error.constants.map{|c| c.to_s}.include?("NoCurrentConnection")
+          class ::Stomp::Error::NoCurrentConnection < RuntimeError ; end
+        end
+
+        @config = mock
+        @config.stubs(:configured).returns(true)
+        @config.stubs(:identity).returns("rspec")
+        @config.stubs(:collectives).returns(["mcollective"])
+
+        logger = mock
+        logger.stubs(:log)
+        logger.stubs(:start)
+        Log.configure(logger)
+
+        Config.stubs(:instance).returns(@config)
+
+        @msg = mock
+        @msg.stubs(:base64_encode!)
+        @msg.stubs(:payload).returns("msg")
+        @msg.stubs(:agent).returns("agent")
+        @msg.stubs(:type).returns(:reply)
+        @msg.stubs(:collective).returns("mcollective")
+
+        @subscription = mock
+        @subscription.stubs("<<").returns(true)
+        @subscription.stubs("include?").returns(false)
+        @subscription.stubs("delete").returns(false)
+
+        @connection = mock
+        @connection.stubs(:subscribe).returns(true)
+        @connection.stubs(:unsubscribe).returns(true)
+
+        @c = Activemq.new
+        @c.instance_variable_set("@subscriptions", @subscription)
+        @c.instance_variable_set("@connection", @connection)
+      end
+
+      describe "#initialize" do
+        it "should set the @config variable" do
+          c = Activemq.new
+          c.instance_variable_get("@config").should == @config
+        end
+
+        it "should set @subscriptions to an empty list" do
+          c = Activemq.new
+          c.instance_variable_get("@subscriptions").should == []
+        end
+      end
+
+      describe "#connect" do
+        it "should not try to reconnect if already connected" do
+          Log.expects(:debug).with("Already connection, not re-initializing connection").once
+          @c.connect
+        end
+
+        it "should support new style config" do
+          pluginconf = {"activemq.pool.size" => "2",
+                        "activemq.pool.1.host" => "host1",
+                        "activemq.pool.1.port" => "6163",
+                        "activemq.pool.1.user" => "user1",
+                        "activemq.pool.1.password" => "password1",
+                        "activemq.pool.1.ssl" => "false",
+                        "activemq.pool.2.host" => "host2",
+                        "activemq.pool.2.port" => "6164",
+                        "activemq.pool.2.user" => "user2",
+                        "activemq.pool.2.password" => "password2",
+                        "activemq.pool.2.ssl" => "true",
+                        "activemq.pool.2.ssl.fallback" => "true",
+                        "activemq.initial_reconnect_delay" => "0.02",
+                        "activemq.max_reconnect_delay" => "40",
+                        "activemq.use_exponential_back_off" => "false",
+                        "activemq.back_off_multiplier" => "3",
+                        "activemq.max_reconnect_attempts" => "5",
+                        "activemq.randomize" => "true",
+                        "activemq.backup" => "true",
+                        "activemq.timeout" => "1",
+                        "activemq.connect_timeout" => "5"}
+
+
+          ENV.delete("STOMP_USER")
+          ENV.delete("STOMP_PASSWORD")
+
+          @config.expects(:pluginconf).returns(pluginconf).at_least_once
+
+          Activemq::EventLogger.expects(:new).returns("logger")
+
+          connector = mock
+          connector.expects(:new).with(:backup => true,
+                                       :back_off_multiplier => 3,
+                                       :max_reconnect_delay => 40.0,
+                                       :timeout => 1,
+                                       :connect_timeout => 5,
+                                       :use_exponential_back_off => false,
+                                       :max_reconnect_attempts => 5,
+                                       :initial_reconnect_delay => 0.02,
+                                       :randomize => true,
+                                       :reliable => true,
+                                       :logger => "logger",
+                                       :hosts => [{:passcode => 'password1',
+                                                   :host => 'host1',
+                                                   :port => 6163,
+                                                   :ssl => false,
+                                                   :login => 'user1'},
+                                                  {:passcode => 'password2',
+                                                   :host => 'host2',
+                                                   :port => 6164,
+                                                   :ssl => true,
+                                                   :login => 'user2'}
+          ])
+
+          @c.expects(:ssl_parameters).with(2, true).returns(true)
+
+          @c.instance_variable_set("@connection", nil)
+          @c.connect(connector)
+        end
+      end
+
+      describe "#ssl_paramaters" do
+        it "should ensure all settings are provided" do
+          pluginconf = {"activemq.pool.1.host" => "host1",
+                        "activemq.pool.1.port" => "6164",
+                        "activemq.pool.1.user" => "user1",
+                        "activemq.pool.1.password" => "password1",
+                        "activemq.pool.1.ssl" => "true",
+                        "activemq.pool.1.ssl.cert" => "rspec"}
+
+          @config.expects(:pluginconf).returns(pluginconf).at_least_once
+
+          expect { @c.ssl_parameters(1, false) }.to raise_error("cert, key and ca has to be supplied for verified SSL mode")
+        end
+
+        it "should verify the ssl files exist" do
+          pluginconf = {"activemq.pool.1.host" => "host1",
+                        "activemq.pool.1.port" => "6164",
+                        "activemq.pool.1.user" => "user1",
+                        "activemq.pool.1.password" => "password1",
+                        "activemq.pool.1.ssl" => "true",
+                        "activemq.pool.1.ssl.cert" => "rspec.cert",
+                        "activemq.pool.1.ssl.key" => "rspec.key",
+                        "activemq.pool.1.ssl.ca" => "rspec1.ca,rspec2.ca"}
+
+          @config.expects(:pluginconf).returns(pluginconf).at_least_once
+
+          File.expects(:exist?).with("rspec.cert").twice.returns(true)
+          File.expects(:exist?).with("rspec.key").twice.returns(true)
+          File.expects(:exist?).with("rspec1.ca").twice.returns(true)
+          File.expects(:exist?).with("rspec2.ca").twice.returns(false)
+
+          expect { @c.ssl_parameters(1, false) }.to raise_error("Cannot find CA file rspec2.ca")
+
+          @c.ssl_parameters(1, true).should == true
+        end
+
+        it "should support fallback mode when there are errors" do
+          pluginconf = {"activemq.pool.1.host" => "host1",
+                        "activemq.pool.1.port" => "6164",
+                        "activemq.pool.1.user" => "user1",
+                        "activemq.pool.1.password" => "password1",
+                        "activemq.pool.1.ssl" => "true"}
+
+          @config.expects(:pluginconf).returns(pluginconf).at_least_once
+
+          @c.ssl_parameters(1, true).should == true
+        end
+
+        it "should fail if fallback isnt enabled" do
+          pluginconf = {"activemq.pool.1.host" => "host1",
+                        "activemq.pool.1.port" => "6164",
+                        "activemq.pool.1.user" => "user1",
+                        "activemq.pool.1.password" => "password1",
+                        "activemq.pool.1.ssl" => "true"}
+
+          @config.expects(:pluginconf).returns(pluginconf).at_least_once
+
+          expect { @c.ssl_parameters(1, false) }.to raise_error
+        end
+      end
+
+      describe "#receive" do
+        it "should receive from the middleware" do
+          payload = mock
+          payload.stubs(:body).returns("msg")
+          payload.stubs(:headers).returns("headers")
+
+          @connection.expects(:receive).returns(payload)
+
+          Message.expects(:new).with("msg", payload, :base64 => true, :headers => "headers").returns("message")
+          @c.instance_variable_set("@base64", true)
+
+          received = @c.receive
+          received.should == "message"
+        end
+
+        it "should sleep and retry if recieving while disconnected" do
+          payload = mock
+          payload.stubs(:body).returns("msg")
+          payload.stubs(:headers).returns("headers")
+
+          Message.stubs(:new).returns("rspec")
+          @connection.expects(:receive).raises(::Stomp::Error::NoCurrentConnection).returns(payload).twice
+          @c.expects(:sleep).with(1)
+
+          @c.receive.should == "rspec"
+        end
+      end
+
+      describe "#publish" do
+        before do
+          @connection.stubs(:publish).with("test", "msg", {}).returns(true)
+        end
+
+        it "should base64 encode a message if configured to do so" do
+          @c.instance_variable_set("@base64", true)
+          @c.expects(:headers_for).returns({})
+          @c.expects(:target_for).returns({:name => "test", :headers => {}})
+          @connection.expects(:publish).with("test", "msg", {})
+          @msg.expects(:base64_encode!)
+
+          @c.publish(@msg)
+        end
+
+        it "should not base64 encode if not configured to do so" do
+          @c.instance_variable_set("@base64", false)
+          @c.expects(:headers_for).returns({})
+          @c.expects(:target_for).returns({:name => "test", :headers => {}})
+          @connection.expects(:publish).with("test", "msg", {})
+          @msg.expects(:base64_encode!).never
+
+          @c.publish(@msg)
+        end
+
+        it "should publish the correct message to the correct target with msgheaders" do
+          @connection.expects(:publish).with("test", "msg", {"test" => "test"}).once
+          @c.expects(:headers_for).returns({"test" => "test"})
+          @c.expects(:target_for).returns({:name => "test", :headers => {}})
+
+          @c.publish(@msg)
+        end
+
+        it "should publish direct messages based on discovered_hosts" do
+          msg = mock
+          msg.stubs(:base64_encode!)
+          msg.stubs(:payload).returns("msg")
+          msg.stubs(:agent).returns("agent")
+          msg.stubs(:collective).returns("mcollective")
+          msg.stubs(:type).returns(:direct_request)
+          msg.expects(:discovered_hosts).returns(["one", "two"])
+
+          @c.expects(:headers_for).with(msg, "one")
+          @c.expects(:headers_for).with(msg, "two")
+          @connection.expects(:publish).with('/queue/mcollective.nodes', 'msg', nil).twice
+
+          @c.publish(msg)
+        end
+      end
+
+      describe "#subscribe" do
+        it "should handle duplicate subscription errors" do
+          @connection.expects(:subscribe).raises(::Stomp::Error::DuplicateSubscription)
+          Log.expects(:error).with(regexp_matches(/already had a matching subscription, ignoring/))
+          @c.subscribe("test", :broadcast, "mcollective")
+        end
+
+        it "should use the make_target correctly" do
+          @c.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
+          @c.subscribe("test", :broadcast, "mcollective")
+        end
+
+        it "should check for existing subscriptions" do
+          @c.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          @subscription.expects("include?").with("rspec").returns(false)
+          @connection.expects(:subscribe).never
+
+          @c.subscribe("test", :broadcast, "mcollective")
+        end
+
+        it "should subscribe to the middleware" do
+          @c.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          @connection.expects(:subscribe).with("test", {}, "rspec")
+          @c.subscribe("test", :broadcast, "mcollective")
+        end
+
+        it "should add to the list of subscriptions" do
+          @c.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          @subscription.expects("<<").with("rspec")
+          @c.subscribe("test", :broadcast, "mcollective")
+        end
+      end
+
+      describe "#unsubscribe" do
+        it "should use make_target correctly" do
+          @c.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}})
+          @c.unsubscribe("test", :broadcast, "mcollective")
+        end
+
+        it "should unsubscribe from the target" do
+          @c.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          @connection.expects(:unsubscribe).with("test", {}, "rspec").once
+
+          @c.unsubscribe("test", :broadcast, "mcollective")
+        end
+
+        it "should delete the source from subscriptions" do
+          @c.expects("make_target").with("test", :broadcast, "mcollective").returns({:name => "test", :headers => {}, :id => "rspec"})
+          @subscription.expects(:delete).with("rspec").once
+
+          @c.unsubscribe("test", :broadcast, "mcollective")
+        end
+      end
+
+      describe "#target_for" do
+        it "should create reply targets based on reply-to headers in requests" do
+          message = mock
+          message.expects(:type).returns(:reply)
+
+          request = mock
+          request.expects(:headers).returns({"reply-to" => "foo"})
+
+          message.expects(:request).returns(request)
+
+          @c.target_for(message).should == {:name => "foo", :headers => {}}
+        end
+
+        it "should create new request targets" do
+          message = mock
+          message.expects(:type).returns(:request).times(3)
+          message.expects(:agent).returns("rspecagent")
+          message.expects(:collective).returns("mcollective")
+
+          @c.expects(:make_target).with("rspecagent", :request, "mcollective")
+          @c.target_for(message)
+        end
+
+        it "should support direct requests" do
+          message = mock
+          message.expects(:type).returns(:direct_request).times(3)
+          message.expects(:agent).returns("rspecagent")
+          message.expects(:collective).returns("mcollective")
+
+          @c.expects(:make_target).with("rspecagent", :direct_request, "mcollective")
+          @c.target_for(message)
+        end
+
+        it "should fail for unknown message types" do
+          message = mock
+          message.stubs(:type).returns(:fail)
+
+          expect {
+            @c.target_for(message)
+          }.to raise_error("Don't now how to create a target for message type fail")
+        end
+      end
+
+      describe "#disconnect" do
+        it "should disconnect from the stomp connection" do
+          @connection.expects(:disconnect)
+          @c.disconnect
+        end
+      end
+
+      describe "#headers_for" do
+        it "should return empty headers if priority is 0" do
+          message = mock
+          message.expects(:type).returns(:foo)
+
+          @c.instance_variable_set("@msgpriority", 0)
+          @c.headers_for(message).should == {}
+        end
+
+        it "should return a priority if priority is non 0" do
+          message = mock
+          message.expects(:type).returns(:foo)
+
+          @c.instance_variable_set("@msgpriority", 1)
+          @c.headers_for(message).should == {"priority" => 1}
+        end
+
+        it "should set mc_identity for direct requests" do
+          message = mock
+          message.expects(:type).returns(:direct_request).twice
+          message.expects(:agent).returns("rspecagent")
+          message.expects(:collective).returns("mcollective")
+          message.expects(:reply_to).returns(nil)
+
+          @c.instance_variable_set("@msgpriority", 0)
+          @c.expects(:make_target).with("rspecagent", :reply, "mcollective").returns({:name => "test"})
+          @c.headers_for(message, "some.node").should == {"mc_identity"=>"some.node", "reply-to"=>"test"}
+        end
+
+        it "should set a reply-to header for :request type messages" do
+          message = mock
+          message.expects(:type).returns(:request).twice
+          message.expects(:agent).returns("rspecagent")
+          message.expects(:collective).returns("mcollective")
+          message.expects(:reply_to).returns(nil)
+
+          @c.instance_variable_set("@msgpriority", 0)
+          @c.expects(:make_target).with("rspecagent", :reply, "mcollective").returns({:name => "test"})
+          @c.headers_for(message).should == {"reply-to" => "test"}
+        end
+
+        it "should set reply-to correctly if the message defines it" do
+          message = mock
+          message.expects(:type).returns(:request).twice
+          message.expects(:agent).returns("rspecagent")
+          message.expects(:collective).returns("mcollective")
+          message.expects(:reply_to).returns("rspec").twice
+
+          @c.headers_for(message).should == {"reply-to" => "rspec"}
+
+        end
+      end
+
+      describe "#make_target" do
+        it "should create correct targets" do
+          @c.make_target("test", :reply, "mcollective").should == {:name => "/queue/mcollective.reply.rspec_#{$$}", :headers => {}, :id => "/queue/mcollective.reply.rspec_#{$$}"}
+          @c.make_target("test", :broadcast, "mcollective").should == {:name => "/topic/mcollective.test.agent", :headers => {}, :id => "/topic/mcollective.test.agent"}
+          @c.make_target("test", :request, "mcollective").should == {:name => "/topic/mcollective.test.agent", :headers => {}, :id => "/topic/mcollective.test.agent"}
+          @c.make_target("test", :direct_request, "mcollective").should == {:headers=>{}, :name=>"/queue/mcollective.nodes", :id => "/queue/mcollective.nodes"}
+          @c.make_target("test", :directed, "mcollective").should == {:name => "/queue/mcollective.nodes", :headers=>{"selector"=>"mc_identity = 'rspec'"}, :id => "directed_to_identity"}
+        end
+
+        it "should raise an error for unknown collectives" do
+          expect {
+            @c.make_target("test", :broadcast, "foo")
+          }.to raise_error("Unknown collective 'foo' known collectives are 'mcollective'")
+        end
+
+        it "should raise an error for unknown types" do
+          expect {
+            @c.make_target("test", :test, "mcollective")
+          }.to raise_error("Unknown target type test")
+        end
+      end
+
+
+      describe "#get_env_or_option" do
+        it "should return the environment variable if set" do
+          ENV["test"] = "rspec_env_test"
+
+          @c.get_env_or_option("test", nil, nil).should == "rspec_env_test"
+
+          ENV.delete("test")
+        end
+
+        it "should return the config option if set" do
+          @config.expects(:pluginconf).returns({"test" => "rspec_test"}).twice
+          @c.get_env_or_option("test", "test", "test").should == "rspec_test"
+        end
+
+        it "should return default if nothing else matched" do
+          @config.expects(:pluginconf).returns({}).once
+          @c.get_env_or_option("test", "test", "test").should == "test"
+        end
+
+        it "should raise an error if no default is supplied" do
+          @config.expects(:pluginconf).returns({}).once
+
+          expect {
+            @c.get_env_or_option("test", "test")
+          }.to raise_error("No test environment or plugin.test configuration option given")
+        end
+      end
+
+      describe "#get_option" do
+        it "should return the config option if set" do
+          @config.expects(:pluginconf).returns({"test" => "rspec_test"}).twice
+          @c.get_option("test").should == "rspec_test"
+        end
+
+        it "should return default option was not found" do
+          @config.expects(:pluginconf).returns({}).once
+          @c.get_option("test", "test").should == "test"
+        end
+
+        it "should raise an error if no default is supplied" do
+          @config.expects(:pluginconf).returns({}).once
+
+          expect {
+            @c.get_option("test")
+          }.to raise_error("No plugin.test configuration option given")
+        end
+      end
+
+      describe "#get_bool_option" do
+        it "should return the default if option isnt set" do
+          @config.expects(:pluginconf).returns({}).once
+          @c.get_bool_option("test", "default").should == "default"
+        end
+
+        ["1", "yes", "true"].each do |boolean|
+          it "should map options to true correctly" do
+            @config.expects(:pluginconf).returns({"test" => boolean}).twice
+            @c.get_bool_option("test", "default").should == true
+          end
+        end
+
+        ["0", "no", "false"].each do |boolean|
+          it "should map options to false correctly" do
+            @config.expects(:pluginconf).returns({"test" => boolean}).twice
+            @c.get_bool_option("test", "default").should == false
+          end
+        end
+
+        it "should return default for non boolean options" do
+          @config.expects(:pluginconf).returns({"test" => "foo"}).twice
+          @c.get_bool_option("test", "default").should == "default"
+        end
+      end
+    end
+  end
+end