mcollective-client 2.0.0 → 2.2.0

data/spec/unit/ddl/dataddl_spec.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module DDL
+    describe DataDDL do
+      before :each do
+        Cache.delete!(:ddl) rescue nil
+        @ddl = DDL.new("rspec", :data, false)
+        @ddl.metadata(:name => "name", :description => "description", :author => "author", :license => "license", :version => "version", :url => "url", :timeout => "timeout")
+      end
+
+      describe "#input" do
+        it "should only allow 'query' as input for data plugins" do
+          ddl = DDL.new("rspec", :data, false)
+          ddl.dataquery(:description => "rspec")
+          ddl.instance_variable_set("@current_entity", :query)
+          ddl.instance_variable_set("@plugintype", :data)
+
+          expect { ddl.input(:rspec, {}) }.to raise_error("The only valid input name for a data query is 'query'")
+        end
+      end
+
+      describe "#dataquery_interface" do
+        it "should return the correct data" do
+          input = {:prompt => "Matcher", :description => "Augeas Matcher", :type => :string, :validation => /.+/, :maxlength => 0}
+          output = {:description=>"rspec", :display_as=>"rspec", :default => nil}
+
+          @ddl.instance_variable_set("@plugintype", :data)
+          @ddl.dataquery(:description => "rspec") do
+            @ddl.output :rspec, output
+            @ddl.input :query, input
+          end
+
+          @ddl.dataquery_interface.should == {:description => "rspec",
+                                              :input => {:query => input.merge(:optional => nil)},
+                                              :output => {:rspec => output}}
+        end
+      end
+
+      describe "#dataquery" do
+        it "should ensure a description is set" do
+          expect { @ddl.dataquery({}) }.to raise_error("Data queries need a :description")
+        end
+
+        it "should ensure only one definition" do
+          @ddl.dataquery(:description => "rspec")
+
+          expect { @ddl.dataquery(:description => "rspec") }.to raise_error("Data queries can only have one definition")
+        end
+
+        it "should create the default structure" do
+          @ddl.dataquery(:description => "rspec")
+          @ddl.instance_variable_set("@plugintype", :data)
+          @ddl.dataquery_interface.should == {:description => "rspec", :input => {}, :output => {}}
+        end
+
+        it "should call the block if given" do
+          @ddl.dataquery(:description => "rspec") { @ddl.instance_variable_get("@current_entity").should == :data }
+        end
+      end
+    end
+  end
+end

data/spec/unit/ddl/discoveryddl_spec.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module DDL
+    describe DiscoveryDDL do
+      before :each do
+        Cache.delete!(:ddl) rescue nil
+        @ddl = DDL.new("rspec", :discovery, false)
+        @ddl.metadata(:name => "name", :description => "description", :author => "author", :license => "license", :version => "version", :url => "url", :timeout => "timeout")
+      end
+
+      describe "#discovery_interface" do
+        it "should return correct data" do
+          @ddl.instance_variable_set("@plugintype", :discovery)
+          @ddl.discovery do
+            @ddl.capabilities :identity
+          end
+
+          @ddl.discovery_interface.should == {:capabilities => [:identity]}
+        end
+      end
+
+      describe "#capabilities" do
+        it "should support non arrays" do
+          @ddl.instance_variable_set("@plugintype", :discovery)
+          @ddl.discovery do
+            @ddl.capabilities :identity
+          end
+          @ddl.discovery_interface.should == {:capabilities => [:identity]}
+        end
+
+        it "should not accept empty capability lists" do
+          @ddl.instance_variable_set("@plugintype", :discovery)
+          @ddl.discovery do
+            expect { @ddl.capabilities [] }.to raise_error("Discovery plugin capabilities can't be empty")
+          end
+        end
+
+        it "should only accept known capabilities" do
+          @ddl.instance_variable_set("@plugintype", :discovery)
+          @ddl.discovery do
+            expect { @ddl.capabilities :rspec }.to raise_error(/rspec is not a valid capability/)
+          end
+        end
+
+        it "should correctly store the capabilities" do
+          @ddl.instance_variable_set("@plugintype", :discovery)
+          @ddl.discovery do
+            @ddl.capabilities [:identity, :classes]
+          end
+          @ddl.discovery_interface.should == {:capabilities => [:identity, :classes]}
+        end
+      end
+    end
+  end
+end

data/spec/unit/ddl_spec.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe DDL do
+    before do
+      Cache.delete!(:ddl) rescue nil
+    end
+
+    describe "#new" do
+      it "should default to agent ddls" do
+        DDL::AgentDDL.expects(:new).once
+        DDL.new("rspec")
+      end
+
+      it "should return the correct plugin ddl class" do
+        DDL.new("rspec", :agent, false).class.should == DDL::AgentDDL
+      end
+
+      it "should default to base when no specific class exist" do
+        DDL.new("rspec", :rspec, false).class.should == DDL::Base
+      end
+    end
+
+    describe "#load_and_cache" do
+      it "should setup the cache" do
+        Cache.setup(:ddl)
+
+        Cache.expects(:setup).once.returns(true)
+        DDL.load_and_cache("rspec", :agent, false)
+      end
+
+      it "should attempt to read from the cache and return found ddl" do
+        Cache.expects(:setup)
+        Cache.expects(:read).with(:ddl, "agent/rspec").returns("rspec")
+        DDL.load_and_cache("rspec", :agent, false).should == "rspec"
+      end
+
+      it "should handle cache misses then create and save a new ddl object" do
+        Cache.expects(:setup)
+        Cache.expects(:read).with(:ddl, "agent/rspec").raises("failed")
+        Cache.expects(:write).with(:ddl, "agent/rspec", kind_of(DDL::AgentDDL)).returns("rspec")
+
+        DDL.load_and_cache("rspec", :agent, false).should == "rspec"
+      end
+    end
+
+    describe "#string_to_number" do
+      it "should turn valid strings into numbers" do
+        ["1", "0", "9999"].each do |i|
+          DDL.string_to_number(i).class.should == Fixnum
+        end
+
+        ["1.1", "0.0", "9999.99"].each do |i|
+          DDL.string_to_number(i).class.should == Float
+        end
+      end
+
+      it "should raise errors for invalid values" do
+        expect { DDL.string_to_number("rspec") }.to raise_error
+      end
+    end
+
+    describe "#string_to_boolean" do
+      it "should turn valid strings into boolean" do
+        ["true", "yes", "1"].each do |t|
+          DDL.string_to_boolean(t).should == true
+          DDL.string_to_boolean(t.upcase).should == true
+        end
+
+        ["false", "no", "0"].each do |f|
+          DDL.string_to_boolean(f).should == false
+          DDL.string_to_boolean(f.upcase).should == false
+        end
+      end
+
+      it "should raise errors for invalid values" do
+        expect { DDL.string_to_boolean("rspec") }.to raise_error
+      end
+    end
+
+  end
+end

data/spec/unit/discovery_spec.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Discovery do
+    before do
+      Config.instance.stubs(:default_discovery_method).returns("mc")
+      @client = mock
+
+      Discovery.any_instance.stubs(:find_known_methods).returns(["mc"])
+      @discovery = Discovery.new(@client)
+    end
+
+    describe "#timeout_for_compound_filter" do
+      it "should return the correct time" do
+        ddl = mock
+        ddl.stubs(:meta).returns({:timeout => 1})
+
+        filter = [Matcher.create_compound_callstack("test().size=1 and rspec().size=1")]
+
+        DDL.expects(:new).with("test_data", :data).returns(ddl)
+        DDL.expects(:new).with("rspec_data", :data).returns(ddl)
+
+        @discovery.timeout_for_compound_filter(filter).should == 2
+      end
+    end
+
+    describe "#discover" do
+      before do
+        ddl = mock
+        ddl.stubs(:meta).returns({:timeout => 2})
+
+        discoverer = mock
+
+        @discovery.stubs(:force_discovery_method_by_filter).returns(false)
+        @discovery.stubs(:ddl).returns(ddl)
+        @discovery.stubs(:check_capabilities)
+        @discovery.stubs(:discovery_class).returns(discoverer)
+      end
+
+      it "should error for non fixnum limits" do
+        expect { @discovery.discover(nil, 0, 1.1) }.to raise_error("Limit has to be an integer")
+      end
+
+      it "should use the DDL timeout if none is specified" do
+        filter = Util.empty_filter
+        @discovery.discovery_class.expects(:discover).with(filter, 2, 0, @client)
+        @discovery.discover(filter, nil, 0)
+      end
+
+      it "should check the discovery method is capable of serving the filter" do
+        @discovery.expects(:check_capabilities).with("filter").raises("capabilities check failed")
+        expect { @discovery.discover("filter", nil, 0) }.to raise_error("capabilities check failed")
+      end
+
+      it "should call the correct discovery plugin" do
+        @discovery.discovery_class.expects(:discover).with("filter", 2, 0, @client)
+        @discovery.discover("filter", nil, 0)
+      end
+
+      it "should handle limits correctly" do
+        @discovery.discovery_class.stubs(:discover).returns([1,2,3,4,5])
+        @discovery.discover(Util.empty_filter, 1, 1).should == [1]
+        @discovery.discover(Util.empty_filter, 1, 0).should == [1,2,3,4,5]
+      end
+    end
+
+    describe "#force_discovery_method_by_filter" do
+      it "should force mc plugin when needed" do
+        options = {:discovery_method => "rspec"}
+
+        Log.expects(:info).with("Switching to mc discovery method because compound filters are used")
+
+        @discovery.expects(:discovery_method).returns("rspec")
+        @client.expects(:options).returns(options)
+        @discovery.force_discovery_method_by_filter({"compound" => ["rspec"]}).should == true
+
+        options[:discovery_method].should == "mc"
+      end
+
+      it "should not force mc plugin when no compound filter is used" do
+        options = {:discovery_method => "rspec"}
+
+        @discovery.expects(:discovery_method).returns("rspec")
+        @discovery.force_discovery_method_by_filter({"compound" => []}).should == false
+
+        options[:discovery_method].should == "rspec"
+      end
+    end
+
+    describe "#check_capabilities" do
+      before do
+        @ddl = mock
+        @discovery.stubs(:ddl).returns(@ddl)
+        @discovery.stubs(:discovery_method).returns("rspec")
+      end
+
+      it "should fail for unsupported capabilities" do
+        @ddl.stubs(:discovery_interface).returns({:capabilities => []})
+
+        filter = Util.empty_filter
+
+        expect { @discovery.check_capabilities(filter.merge({"cf_class" => ["filter"]})) }.to raise_error(/Cannot use class filters/)
+
+        ["fact", "identity", "compound"].each do |type|
+          expect { @discovery.check_capabilities(filter.merge({type => ["filter"]})) }.to raise_error(/Cannot use #{type} filters/)
+        end
+      end
+    end
+
+    describe "#ddl" do
+      before do
+        @ddl = mock
+        @ddl.stubs(:meta).returns({:name => "mc"})
+      end
+
+      it "should create an instance of the right ddl" do
+        @discovery.instance_variable_set("@ddl", nil)
+        @client.stubs(:options).returns({})
+        DDL.expects(:new).with("mc", :discovery).returns(@ddl)
+        @discovery.ddl
+      end
+
+      it "should reload the ddl if the method has changed" do
+        @discovery.instance_variable_set("@ddl", @ddl)
+        @discovery.stubs(:discovery_method).returns("rspec")
+        DDL.expects(:new).with("rspec", :discovery).returns(@ddl)
+        @discovery.ddl
+      end
+    end
+
+    describe "#discovery_class" do
+      it "should try to load the class if not already loaded" do
+        @discovery.expects(:discovery_method).returns("mc")
+        PluginManager.expects(:loadclass).with("MCollective::Discovery::Mc")
+        Discovery.expects(:const_defined?).with("Mc").returns(false)
+        Discovery.expects(:const_get).with("Mc").returns("rspec")
+        @discovery.discovery_class.should == "rspec"
+      end
+
+      it "should not load the class again if its already loaded" do
+        @discovery.expects(:discovery_method).returns("mc")
+        PluginManager.expects(:loadclass).never
+        Discovery.expects(:const_defined?).with("Mc").returns(true)
+        Discovery.expects(:const_get).with("Mc").returns("rspec")
+        @discovery.discovery_class.should == "rspec"
+      end
+    end
+
+    describe "#initialize" do
+      it "should load all the known methods" do
+        @discovery.instance_variable_get("@known_methods").should == ["mc"]
+      end
+    end
+
+    describe "#find_known_methods" do
+      it "should use the PluginManager to find plugins of type 'discovery'" do
+        @discovery.find_known_methods.should == ["mc"]
+      end
+    end
+
+    describe "#has_method?" do
+      it "should correctly report the availability of a discovery method" do
+        @discovery.has_method?("mc").should == true
+        @discovery.has_method?("rspec").should == false
+      end
+    end
+
+    describe "#descovery_method" do
+      it "should default to 'mc'" do
+        @client.expects(:options).returns({})
+        @discovery.discovery_method.should == "mc"
+      end
+
+      it "should give preference to the client options" do
+        @client.expects(:options).returns({:discovery_method => "rspec"}).twice
+        Config.instance.expects(:direct_addressing).returns(true)
+        @discovery.expects(:has_method?).with("rspec").returns(true)
+        @discovery.discovery_method.should == "rspec"
+      end
+
+      it "should validate the discovery method exists" do
+        @client.expects(:options).returns({:discovery_method => "rspec"}).twice
+        expect { @discovery.discovery_method.should == "rspec" }.to raise_error("Unknown discovery method rspec")
+      end
+
+      it "should only allow custom discovery methods if direct_addressing is enabled" do
+        @client.expects(:options).returns({:discovery_method => "rspec"}).twice
+        Config.instance.expects(:direct_addressing).returns(false)
+        @discovery.expects(:has_method?).with("rspec").returns(true)
+        expect { @discovery.discovery_method.should == "rspec" }.to raise_error("Custom discovery methods require direct addressing mode")
+      end
+    end
+  end
+end

data/spec/unit/facts/base_spec.rb

@@ -13,7 +13,7 @@ module MCollective::Facts
 
     describe "#inherited" do
       it "should add classes to the plugin manager" do
-        MCollective::PluginManager.stubs("<<").with({:type => "facts_plugin", :class => "MCollective::Facts::Bar"})
+        MCollective::PluginManager.expects("<<").with({:type => "facts_plugin", :class => "MCollective::Facts::Bar"})
 
         class Bar<Base; end
       end

data/spec/unit/generators/agent_generator_spec.rb

@@ -0,0 +1,72 @@
+#! /usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module Generators
+      describe AgentGenerator do
+
+        describe "#create_ddl" do
+
+          before :each do
+            AgentGenerator.any_instance.stubs(:create_plugin_content)
+            AgentGenerator.any_instance.stubs(:create_plugin_string)
+            AgentGenerator.any_instance.stubs(:write_plugins)
+            AgentGenerator.any_instance.expects(:create_metadata_string).returns("metadata\n")
+          end
+
+          it "should create a ddl with nothing but metadata if no actions are specified" do
+            result = AgentGenerator.new("foo").ddl
+            result.should == "metadata\n"
+          end
+
+          it "should add action strings to metadata if there are actions specfied" do
+            result = AgentGenerator.new("foo", ["action1", "action2"]).ddl
+            expected = File.read(File.join(File.dirname(__FILE__), "snippets", "agent_ddl"))
+            result.should == expected
+          end
+        end
+
+        describe "#create_plugin_content" do
+          before :each do
+            AgentGenerator.any_instance.stubs(:create_plugin_string)
+            AgentGenerator.any_instance.stubs(:write_plugins)
+            AgentGenerator.any_instance.stubs(:create_metadata_string).returns("metadata\n")
+            AgentGenerator.any_instance.stubs(:create_ddl)
+          end
+
+          it "should create the correct pluginf ile content with actions if they are specified" do
+            AgentGenerator.any_instance.stubs(:create_metadata_string).returns("meta\n")
+            result = AgentGenerator.new("foo", ["action1", "action2"]).content
+            result.should == "      action \"action1\" do\n      end\n\n      action \"action2\" do\n      end\n"
+          end
+        end
+
+        describe "#action_help" do
+          before :each do
+            AgentGenerator.any_instance.stubs(:create_plugin_content)
+            AgentGenerator.any_instance.stubs(:create_plugin_string)
+            AgentGenerator.any_instance.stubs(:write_plugins)
+            AgentGenerator.any_instance.stubs(:create_metadata_string).returns("metadata\n")
+          end
+
+          it "should load and return the action_help snippet" do
+            erb = mock
+            erb.stubs(:result).returns("result")
+            File.stubs(:dirname).returns("/tmp")
+            File.expects(:read).with("/tmp/templates/action_snippet.erb").returns("result")
+            ERB.expects(:new).with("result").returns(erb)
+            AgentGenerator.new("foo", ["action"])
+          end
+
+          it "should raise an error if the action_help snippet does not exist" do
+            File.stubs(:dirname).returns("/tmp")
+            File.stubs(:read).raises(Errno::ENOENT, "No such file or directory")
+            expect{
+              AgentGenerator.new("foo", ["action"])
+            }.to raise_error(Errno::ENOENT)
+          end
+        end
+      end
+  end
+end