mcollective-client 2.0.0 → 2.2.0

data/spec/unit/rpc/reply_spec.rb

@@ -6,7 +6,14 @@ module MCollective
   module RPC
     describe Reply do
       before(:each) do
-        @reply = Reply.new
+        Cache.delete!(:ddl) rescue nil
+
+        ddl = stub
+        ddl.stubs(:action_interface).returns({:output => {}})
+        ddl.stubs(:actions).returns(["rspec"])
+        ddl.stubs(:pluginname).returns("rspec")
+
+        @reply = Reply.new("rspec", ddl)
       end
 
       describe "#initialize" do
@@ -23,6 +30,29 @@ module MCollective
         end
       end
 
+      describe "#initialize_data" do
+        before do
+          Log.stubs(:warn)
+          @ddl = DDL.new("rspec", :agent, false)
+        end
+
+        it "should set defaults correctly" do
+          @ddl.action :rspec, :description => "testing rspec" do
+            @ddl.output :one, :description => "rspec test", :display_as => "rspec", :default => "default"
+            @ddl.output :three, :description => "rspec test", :display_as => "rspec", :default => []
+            @ddl.output :two, :description => "rspec test", :display_as => "rspec"
+          end
+
+          reply = Reply.new(:rspec, @ddl)
+          reply.data.should == {:one => "default", :two => nil, :three => []}
+        end
+
+        it "should detect missing actions" do
+          reply = Reply.new(:rspec, @ddl)
+          expect { reply.initialize_data }.to raise_error(/No action 'rspec' defined/)
+        end
+      end
+
       describe "#fail" do
         it "should set statusmsg" do
           @reply.fail "foo"

data/spec/unit/rpc/request_spec.rb

@@ -7,15 +7,24 @@ module MCollective
     describe Request do
       before(:each) do
         @req = {:msgtime        => Time.now,
-          :senderid        => "spec test",
-          :requestid       => "12345",
-          :callerid        => "rip"}
+                :senderid        => "spec test",
+                :requestid       => "12345",
+                :callerid        => "rip"}
 
         @req[:body] = {:action => "test",
-          :data   => {:foo => "bar", :process_results => true},
-          :agent  => "tester"}
+                       :data   => {:foo => "bar", :process_results => true},
+                       :agent  => "tester"}
 
-        @request = Request.new(@req)
+        @ddl = DDL.new("rspec", :agent, false)
+
+        @request = Request.new(@req, @ddl)
+      end
+
+      describe "#validate!" do
+        it "should validate the request using the supplied DDL" do
+          @ddl.expects(:validate_rpc_request).with("test", {:foo => "bar", :process_results => true})
+          @request.validate!
+        end
       end
 
       describe "#initialize" do
@@ -49,7 +58,7 @@ module MCollective
 
         it "should set unknown caller if none is supplied" do
           @req.delete(:callerid)
-          Request.new(@req).caller.should == "unknown"
+          Request.new(@req, @ddl).caller.should == "unknown"
         end
       end
 
@@ -60,26 +69,26 @@ module MCollective
 
         it "should return false for non hash data" do
           @req[:body][:data] = "foo"
-          Request.new(@req).include?(:foo).should == false
+          Request.new(@req, @ddl).include?(:foo).should == false
         end
       end
 
       describe "#should_respond?" do
         it "should return true if the header is absent" do
           @req[:body][:data].delete(:process_results)
-          Request.new(@req).should_respond?.should == true
+          Request.new(@req, @ddl).should_respond?.should == true
         end
 
         it "should return correct value" do
           @req[:body][:data][:process_results] = false
-          Request.new(@req).should_respond?.should == false
+          Request.new(@req, @ddl).should_respond?.should == false
         end
       end
 
       describe "#[]" do
         it "should return nil for non hash data" do
           @req[:body][:data] = "foo"
-          Request.new(@req)["foo"].should == nil
+          Request.new(@req, @ddl)["foo"].should == nil
         end
 
         it "should return correct data" do
@@ -91,6 +100,18 @@ module MCollective
         end
       end
 
+      describe "#fetch" do
+        it "should return nil for non hash data" do
+          @req[:body][:data] = "foo"
+          Request.new(@req, @ddl)["foo"].should == nil
+        end
+
+        it "should fetch data with the correct default behavior" do
+          @request.fetch(:foo, "default").should == "bar"
+          @request.fetch(:rspec, "default").should == "default"
+        end
+      end
+
       describe "#to_hash" do
         it "should have the correct keys" do
           @request.to_hash.keys.sort.should == [:action, :agent, :data]
@@ -106,7 +127,7 @@ module MCollective
 
         it "should return the correct data" do
           @request.to_hash[:data].should == {:foo => "bar",
-            :process_results => true}
+                                             :process_results => true}
         end
       end
     end

data/spec/unit/rpc/result_spec.rb

@@ -44,6 +44,13 @@ module MCollective
         end
       end
 
+      describe "#fetch" do
+        it "should fetch data with the correct default behavior" do
+          @result.fetch(:foo, "default").should == "bar"
+          @result.fetch(:rspec, "default").should == "default"
+        end
+      end
+
       describe "#each" do
         it "should itterate all the pairs" do
           data = {}

data/spec/unit/rpc/stats_spec.rb

@@ -6,16 +6,18 @@ module MCollective
   module RPC
     describe Stats do
       before(:each) do
-        @expected = {:discoverytime=>0,
-          :okcount=>0,
-          :blocktime=>0,
-          :failcount=>0,
-          :noresponsefrom=>[],
-          :responses=>0,
-          :totaltime=>0,
-          :discovered=>0,
-          :starttime=>1300031826.0,
-          :discovered_nodes=>[]}
+        @expected = {:discoverytime => 0,
+                     :okcount => 0,
+                     :blocktime => 0,
+                     :failcount => 0,
+                     :noresponsefrom => [],
+                     :responses => 0,
+                     :totaltime => 0,
+                     :discovered => 0,
+                     :starttime => 1300031826.0,
+                     :requestid => nil,
+                     :aggregate_summary => [],
+                     :discovered_nodes => []}
 
         @stats = Stats.new
       end
@@ -43,9 +45,7 @@ module MCollective
           Time.stubs(:now).returns(Time.at(1300031826))
           s = Stats.new
 
-          @expected.keys.each do |k|
-            @expected[k].should == s.to_hash[k]
-          end
+          s.to_hash.should == @expected
         end
       end
 
@@ -280,7 +280,7 @@ module MCollective
           @stats.discovered_agents ["foo", "bar"]
           @stats.finish_request
 
-          @stats.no_response_report.should match(Regexp.new(/No response from.+foo.+bar/m))
+          @stats.no_response_report.should match(Regexp.new(/No response from.+bar\s+foo/m))
         end
       end
     end

data/spec/unit/rpc_spec.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe RPC do
+    describe "#const_missing" do
+      it "should deprecate only the DDL class" do
+        Log.expects(:warn).with("MCollective::RPC::DDL is deprecatd, please use MCollective::DDL instead")
+        MCollective::RPC::DDL.should == MCollective::DDL
+
+        expect { MCollective::RPC::Foo }.to raise_error(NameError)
+      end
+    end
+  end
+end

data/spec/unit/security/base_spec.rb

@@ -248,29 +248,29 @@ module MCollective
       end
 
       describe "#validrequest?" do
-        it "should log an error when not implimented" do
-          MCollective::Log.expects(:error).with("validrequest? is not implimented in MCollective::Security::Base")
+        it "should log an error when not implemented" do
+          MCollective::Log.expects(:error).with("validrequest? is not implemented in MCollective::Security::Base")
           @plugin.validrequest?(nil)
         end
       end
 
       describe "#encoderequest" do
-        it "should log an error when not implimented" do
-          MCollective::Log.expects(:error).with("encoderequest is not implimented in MCollective::Security::Base")
+        it "should log an error when not implemented" do
+          MCollective::Log.expects(:error).with("encoderequest is not implemented in MCollective::Security::Base")
           @plugin.encoderequest(nil, nil, nil)
         end
       end
 
       describe "#encodereply" do
-        it "should log an error when not implimented" do
-          MCollective::Log.expects(:error).with("encodereply is not implimented in MCollective::Security::Base")
+        it "should log an error when not implemented" do
+          MCollective::Log.expects(:error).with("encodereply is not implemented in MCollective::Security::Base")
           @plugin.encodereply(nil, nil, nil)
         end
       end
 
       describe "#decodemsg" do
-        it "should log an error when not implimented" do
-          MCollective::Log.expects(:error).with("decodemsg is not implimented in MCollective::Security::Base")
+        it "should log an error when not implemented" do
+          MCollective::Log.expects(:error).with("decodemsg is not implemented in MCollective::Security::Base")
           @plugin.decodemsg(nil)
         end
       end

data/spec/unit/ssl_spec.rb

@@ -50,7 +50,7 @@ module MCollective
       end
 
       it "should take the configured value when present" do
-        Config.any_instance.stubs("ssl_cipher").returns("aes-128-cbc")
+        Config.instance.stubs("ssl_cipher").returns("aes-128-cbc")
         @ssl = SSL.new("#{@rootdir}/../fixtures/test-public.pem", "#{@rootdir}/../fixtures/test-private.pem")
 
         @ssl.ssl_cipher.should == "aes-128-cbc"
@@ -62,7 +62,7 @@ module MCollective
       end
 
       it "should prefer the supplied cipher over configured cipher" do
-        Config.any_instance.stubs("aes_key_size").returns("foo-foo-foo")
+        Config.instance.stubs("aes_key_size").returns("foo-foo-foo")
         @ssl = SSL.new("#{@rootdir}/../fixtures/test-public.pem", "#{@rootdir}/../fixtures/test-private.pem", nil, "aes-128-cbc")
 
         @ssl.ssl_cipher.should == "aes-128-cbc"
@@ -82,6 +82,14 @@ module MCollective
         }.to raise_error("Could not find key /nonexisting")
       end
 
+      it "should fail on existing, empty files" do
+        File.expects(:exist?).with('key').returns(true)
+        File.expects(:zero?).with('key').returns(true)
+        expect{
+          @ssl.read_key(:public, 'key')
+        }.to raise_error("public key file 'key' is empty")
+      end
+
       it "should fail on unknown key types" do
         expect {
           @ssl.read_key(:unknown, @ssl.public_key_file)
@@ -240,5 +248,15 @@ module MCollective
         }.to raise_error("Crypted data should include data")
       end
     end
+
+    describe "#uuid" do
+      it "should produce repeatable uuids" do
+        SSL.uuid("hello world").should == SSL.uuid("hello world")
+      end
+
+      it "should not always produce the same uuid" do
+        SSL.uuid.should_not == SSL.uuid
+      end
+    end
   end
 end

data/spec/unit/string_spec.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+class String
+  describe "#start_with?" do
+    it "should return true for matches" do
+      "hello world".start_with?("hello").should == true
+    end
+
+    it "should return false for non matches" do
+      "hello world".start_with?("world").should == false
+    end
+  end
+end

data/spec/unit/util_spec.rb

@@ -107,12 +107,12 @@ module MCollective
           Util.make_subscriptions("test", "test", "test")
         }.to raise_error("Unknown target type test")
 
-        Config.any_instance.stubs(:collectives).returns(["test"])
+        Config.instance.stubs(:collectives).returns(["test"])
         Util.make_subscriptions("test", :broadcast, "test")
       end
 
       it "should return a subscription for each collective" do
-        Config.any_instance.stubs(:collectives).returns(["collective1", "collective2"])
+        Config.instance.stubs(:collectives).returns(["collective1", "collective2"])
         Util.make_subscriptions("test", :broadcast).should == [{:type=>:broadcast,
                                                                  :agent=>"test",
                                                                  :collective=>"collective1"},
@@ -122,7 +122,7 @@ module MCollective
       end
 
       it "should validate given collective" do
-        Config.any_instance.stubs(:collectives).returns(["collective1", "collective2"])
+        Config.instance.stubs(:collectives).returns(["collective1", "collective2"])
 
         expect {
           Util.make_subscriptions("test", :broadcast, "test")
@@ -130,7 +130,7 @@ module MCollective
       end
 
       it "should return a single subscription array given a collective" do
-        Config.any_instance.stubs(:collectives).returns(["collective1", "collective2"])
+        Config.instance.stubs(:collectives).returns(["collective1", "collective2"])
         Util.make_subscriptions("test", :broadcast, "collective1").should == [{:type=>:broadcast, :agent=>"test", :collective=>"collective1"}]
       end
     end
@@ -194,10 +194,11 @@ module MCollective
 
     describe "#default_options" do
       it "should supply correct default options" do
+        Config.instance.stubs(:default_discovery_options).returns([])
         empty_filter = Util.empty_filter
         config_file = Util.config_file_for_user
 
-        Util.default_options.should == {:verbose => false, :disctimeout => 2, :timeout => 5, :config => config_file, :filter => empty_filter, :collective => nil}
+        Util.default_options.should == {:verbose => false, :disctimeout => nil, :timeout => 5, :config => config_file, :filter => empty_filter, :collective => nil, :discovery_method => nil, :discovery_options => []}
       end
     end
 
@@ -316,26 +317,145 @@ module MCollective
       end
     end
 
-    describe "#eval_compound_statement" do
-      it "should return correctly on a regex class statement" do
-        Util.expects(:has_cf_class?).with("/foo/").returns(true)
-        Util.eval_compound_statement({"statement" => "/foo/"}).should == true
-        Util.expects(:has_cf_class?).with("/foo/").returns(false)
-        Util.eval_compound_statement({"statement" => "/foo/"}).should == false
+    describe "#colorize" do
+      it "should not add color codes when color is disabled" do
+        Config.instance.stubs(:color).returns(false)
+        Util.colorize(:red, "hello world").should == "hello world"
       end
 
-      it "should return correcly for string and regex facts" do
-        Util.expects(:has_fact?).with("foo", "bar", "==").returns(true)
-        Util.eval_compound_statement({"statement" => "foo=bar"}).should == "true"
-        Util.expects(:has_fact?).with("foo", "/bar/", "=~").returns(false)
-        Util.eval_compound_statement({"statement" => "foo=/bar/"}).should == "false"
+      it "should add color when color is enabled" do
+        Config.instance.stubs(:color).returns(true)
+        Util.colorize(:red, "hello world").should == "hello world"
       end
+    end
+
+    describe "#align_text" do
+      it "should default to 80 if the terminal dimensions are unknown" do
+        Util.stubs(:terminal_dimensions).returns([0,0])
+
+        rootdir = File.dirname(__FILE__)
+        input = File.read("#{rootdir}/../fixtures/util/4.in")
+        output = File.read("#{rootdir}/../fixtures/util/4.out")
+
+        (Util.align_text(input, nil, 3) + "\n").should == output
+      end
+
+      it "should return the origional string if console lines are 0" do
+        result = Util.align_text("test", 0)
+        result.should == "test"
+      end
+
+      it "should return the origional string if preamble is greater than console lines" do
+        result = Util.align_text("test", 5, 6)
+        result.should == "test"
+      end
+
+      it "should return a string prefixed by the preamble" do
+        result = Util.align_text("test")
+        result.should == "     test"
+      end
+
+      it "should correctly align strings" do
+        rootdir = File.dirname(__FILE__)
+        (1..2).each do |i|
+          input = File.read("#{rootdir}/../fixtures/util/#{i}.in")
+          output = File.read("#{rootdir}/../fixtures/util/#{i}.out")
+
+          (Util.align_text(input, 158 , 5) + "\n").should == output
+        end
+
+        input = File.read("#{rootdir}/../fixtures/util/3.in")
+        output = File.read("#{rootdir}/../fixtures/util/3.out")
+
+        (Util.align_text(input, 30, 0) + "\n").should == output
+      end
+    end
+
+    describe "#terminal_dimensions" do
+      it "should return 0 if there is no tty" do
+        stdout = mock()
+        stdout.expects(:tty?).returns(false)
+        result = Util.terminal_dimensions(stdout)
+        result.should == [0,0]
+      end
+
+      it "should return the default dimensions for a windows terminal" do
+        stdout = mock()
+        stdout.expects(:tty?).returns(true)
+        Util.expects(:windows?).returns(true)
+        result = Util.terminal_dimensions(stdout)
+        result.should == [80, 40]
+      end
+
+      it "should return 0 if an exception was raised" do
+        stdout = mock()
+        stdout.expects(:tty?).raises("error")
+        result = Util.terminal_dimensions(stdout)
+        result.should == [0, 0]
+      end
+
+      it "should return the correct dimensions if ENV columns and lines are set" do
+
+        stdout = mock()
+        stdout.expects(:tty?).returns(true)
+        environment = mock()
+        environment.expects(:[]).with("COLUMNS").returns(5).twice
+        environment.expects(:[]).with("LINES").returns(5).twice
+        result = Util.terminal_dimensions(stdout, environment)
+        result.should == [5,5]
+      end
+
+      it "should return the correct dimensions if ENV term is set and tput is present" do
+        stdout = mock()
+        stdout.expects(:tty?).returns(true)
+        environment = mock()
+        environment.expects(:[]).with("COLUMNS").returns(false)
+        environment.expects(:[]).with("TERM").returns(true)
+
+        Util.expects(:command_in_path?).with("tput").returns(true)
+        Util.stubs(:`).returns("5")
+
+        result = Util.terminal_dimensions(stdout, environment)
+        result.should == [5,5]
+      end
+
+      it "should return the correct dimensions if stty is present" do
+        stdout = mock()
+        stdout.expects(:tty?).returns(true)
+
+        environment = mock()
+        environment.expects(:[]).with("COLUMNS").returns(false)
+        environment.expects(:[]).with("TERM").returns(false)
+
+        Util.expects(:command_in_path?).with("stty").returns(true)
+        Util.stubs(:`).returns("5 5")
+
+        result = Util.terminal_dimensions(stdout, environment)
+        result.should == [5,5]
+      end
+    end
+
+    describe "#command_in_path?" do
+      it "should return true if the command is found" do
+        File.stubs(:exist?).returns(true)
+        result = Util.command_in_path?("test")
+        result.should == true
+      end
+
+      it "should return false if the command cannot be found" do
+        File.stubs(:exist?).returns(false)
+        result = Util.command_in_path?("test")
+        result.should == false
+      end
+    end
+
+    describe "#versioncmp" do
+      it "should be able to sort a long set of various unordered versions" do
+        ary = %w{ 1.1.6 2.3 1.1a 3.0 1.5 1 2.4 1.1-4 2.3.1 1.2 2.3.0 1.1-3 2.4b 2.4 2.40.2 2.3a.1 3.1 0002 1.1-5 1.1.a 1.06}
+
+        newary = ary.sort {|a, b| Util.versioncmp(a,b) }
 
-      it "should return correctly on a string class statement" do
-        Util.expects(:has_cf_class?).with("foo").returns(true)
-        Util.eval_compound_statement({"statement" => "foo"}).should == true
-        Util.expects(:has_cf_class?).with("foo").returns(false)
-        Util.eval_compound_statement({"statement" => "foo"}).should == false
+        newary.should == ["0002", "1", "1.06", "1.1-3", "1.1-4", "1.1-5", "1.1.6", "1.1.a", "1.1a", "1.2", "1.5", "2.3", "2.3.0", "2.3.1", "2.3a.1", "2.4", "2.4", "2.4b", "2.40.2", "3.0", "3.1"]
       end
     end
   end