mcollective-client 1.3.3

data/spec/unit/rpc/request_spec.rb

@@ -0,0 +1,115 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module RPC
+    describe Request do
+      before(:each) do
+        @req = {:msgtime        => Time.now,
+          :senderid        => "spec test",
+          :requestid       => "12345",
+          :callerid        => "rip"}
+
+        @req[:body] = {:action => "test",
+          :data   => {:foo => "bar", :process_results => true},
+          :agent  => "tester"}
+
+        @request = Request.new(@req)
+      end
+
+      describe "#initialize" do
+        it "should set time" do
+          @request.time.should == @req[:msgtime]
+        end
+
+        it "should set action" do
+          @request.action.should == "test"
+        end
+
+        it "should set data" do
+          @request.data.should == {:foo => "bar", :process_results => true}
+        end
+
+        it "should set sender" do
+          @request.sender.should == "spec test"
+        end
+
+        it "should set agent" do
+          @request.agent.should == "tester"
+        end
+
+        it "should set uniqid" do
+          @request.uniqid.should == "12345"
+        end
+
+        it "should set caller" do
+          @request.caller.should == "rip"
+        end
+
+        it "should set unknown caller if none is supplied" do
+          @req.delete(:callerid)
+          Request.new(@req).caller.should == "unknown"
+        end
+      end
+
+      describe "#include?" do
+        it "should correctly report on hash contents" do
+          @request.include?(:foo).should == true
+        end
+
+        it "should return false for non hash data" do
+          @req[:body][:data] = "foo"
+          Request.new(@req).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
+        end
+
+        it "should return correct value" do
+          @req[:body][:data][:process_results] = false
+          Request.new(@req).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
+        end
+
+        it "should return correct data" do
+          @request[:foo].should == "bar"
+        end
+
+        it "should return nil for absent data" do
+          @request[:bar].should == nil
+        end
+      end
+
+      describe "#to_hash" do
+        it "should have the correct keys" do
+          @request.to_hash.keys.sort.should == [:action, :agent, :data]
+        end
+
+        it "should return the correct agent" do
+          @request.to_hash[:agent].should == "tester"
+        end
+
+        it "should return the correct action" do
+          @request.to_hash[:action].should == "test"
+        end
+
+        it "should return the correct data" do
+          @request.to_hash[:data].should == {:foo => "bar",
+            :process_results => true}
+        end
+      end
+    end
+  end
+end
+

data/spec/unit/rpc/result_spec.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module RPC
+    describe Result do
+      before(:each) do
+        @result = Result.new("tester", "test", {:foo => "bar", :bar => "baz"})
+      end
+
+      it "should include Enumerable" do
+        Result.ancestors.include?(Enumerable).should == true
+      end
+
+      describe "#initialize" do
+        it "should set the agent" do
+          @result.agent.should == "tester"
+        end
+
+        it "should set the action" do
+          @result.action.should == "test"
+        end
+
+        it "should set the results" do
+          @result.results.should == {:foo => "bar", :bar => "baz"}
+        end
+      end
+
+      describe "#[]" do
+        it "should access the results hash and return correct data" do
+          @result[:foo].should == "bar"
+          @result[:bar].should == "baz"
+        end
+      end
+
+      describe "#[]=" do
+        it "should set the correct result data" do
+          @result[:meh] = "blah"
+
+          @result[:foo].should == "bar"
+          @result[:bar].should == "baz"
+          @result[:meh].should == "blah"
+        end
+      end
+
+      describe "#each" do
+        it "should itterate all the pairs" do
+          data = {}
+
+          @result.each {|k,v| data[k] = v}
+
+          data[:foo].should == "bar"
+          data[:bar].should == "baz"
+        end
+      end
+
+      describe "#to_json" do
+        it "should correctly json encode teh data" do
+          result = Result.new("tester", "test", {:statuscode => 0, :statusmsg => "OK", :sender => "rspec",  :data => {:foo => "bar", :bar => "baz"}})
+          JSON.load(result.to_json).should == {"agent" => "tester", "action" => "test", "statuscode" => 0, "statusmsg" => "OK", "sender" => "rspec", "data" => {"foo" => "bar", "bar" => "baz"}}
+        end
+      end
+    end
+  end
+end

data/spec/unit/rpc/stats_spec.rb

@@ -0,0 +1,288 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+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=>[]}
+
+        @stats = Stats.new
+      end
+
+      describe "#initialize" do
+        it "should reset stats on creation" do
+          Stats.any_instance.stubs(:reset).returns(true).once
+          s = Stats.new
+        end
+      end
+
+      describe "#reset" do
+        it "should initialize data correctly" do
+          Time.stubs(:now).returns(Time.at(1300031826))
+          s = Stats.new
+
+          @expected.keys.each do |k|
+            @expected[k].should == s.send(k)
+          end
+        end
+      end
+
+      describe "#to_hash" do
+        it "should return correct stats" do
+          Time.stubs(:now).returns(Time.at(1300031826))
+          s = Stats.new
+
+          @expected.keys.each do |k|
+            @expected[k].should == s.to_hash[k]
+          end
+        end
+      end
+
+      describe "#[]" do
+        it "should return stat values" do
+          Time.stubs(:now).returns(Time.at(1300031826))
+          s = Stats.new
+
+          @expected.keys.each do |k|
+            @expected[k].should == s[k]
+          end
+        end
+
+        it "should return nil for unknown values" do
+          @stats["foo"].should == nil
+        end
+      end
+
+      describe "#ok" do
+        it "should increment stats" do
+          @stats.ok
+          @stats[:okcount].should == 1
+        end
+      end
+
+      describe "#fail" do
+        it "should increment stats" do
+          @stats.fail
+          @stats.failcount.should == 1
+        end
+      end
+
+      describe "#time_discovery" do
+        it "should set start time correctly" do
+          Time.stubs(:now).returns(Time.at(1300031826))
+
+          @stats.time_discovery(:start)
+
+          @stats.instance_variable_get("@discovery_start").should == 1300031826.0
+        end
+
+        it "should record the difference correctly" do
+          Time.stubs(:now).returns(Time.at(1300031826))
+          @stats.time_discovery(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031827))
+          @stats.time_discovery(:end)
+
+          @stats.discoverytime.should == 1.0
+        end
+
+        it "should handle unknown actions and set discovery time to 0" do
+          Time.stubs(:now).returns(Time.at(1300031826))
+          @stats.time_discovery(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031827))
+          @stats.time_discovery(:stop)
+
+          @stats.discoverytime.should == 0
+        end
+
+      end
+
+      describe "#client_stats=" do
+        it "should store stats correctly" do
+          data = {}
+          keys = [:noresponsefrom, :responses, :starttime, :blocktime, :totaltime, :discoverytime]
+          keys.each {|k| data[k] = k}
+
+          @stats.client_stats = data
+
+          keys.each do |k|
+            @stats[k].should == data[k]
+          end
+        end
+
+        it "should not store discovery time if it was already stored" do
+          data = {}
+          keys = [:noresponsefrom, :responses, :starttime, :blocktime, :totaltime, :discoverytime]
+          keys.each {|k| data[k] = k}
+
+          Time.stubs(:now).returns(Time.at(1300031826))
+          @stats.time_discovery(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031827))
+          @stats.time_discovery(:end)
+
+          dtime = @stats.discoverytime
+
+          @stats.client_stats = data
+
+          @stats.discoverytime.should == dtime
+        end
+      end
+
+      describe "#time_block_execution" do
+        it "should set start time correctly" do
+          Time.stubs(:now).returns(Time.at(1300031826))
+
+          @stats.time_block_execution(:start)
+
+          @stats.instance_variable_get("@block_start").should == 1300031826.0
+        end
+
+        it "should record the difference correctly" do
+          Time.stubs(:now).returns(Time.at(1300031826))
+          @stats.time_block_execution(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031827))
+          @stats.time_block_execution(:end)
+
+          @stats.blocktime.should == 1
+        end
+
+        it "should handle unknown actions and set discovery time to 0" do
+          Time.stubs(:now).returns(Time.at(1300031826))
+          @stats.time_block_execution(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031827))
+          @stats.time_block_execution(:stop)
+
+          @stats.blocktime.should == 0
+        end
+      end
+
+      describe "#discovered_agents" do
+        it "should set discovered_nodes" do
+          nodes = ["one", "two"]
+          @stats.discovered_agents(nodes)
+          @stats.discovered_nodes.should == nodes
+        end
+
+        it "should set discovered count" do
+          nodes = ["one", "two"]
+          @stats.discovered_agents(nodes)
+          @stats.discovered.should == 2
+        end
+      end
+
+      describe "#finish_request" do
+        it "should calculate totaltime correctly" do
+          Time.stubs(:now).returns(Time.at(1300031824))
+          @stats.time_discovery(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031825))
+          @stats.time_discovery(:end)
+
+          Time.stubs(:now).returns(Time.at(1300031826))
+          @stats.time_block_execution(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031827))
+          @stats.time_block_execution(:end)
+
+          @stats.discovered_agents(["one", "two", "three"])
+          @stats.node_responded("one")
+          @stats.node_responded("two")
+
+          @stats.finish_request
+
+          @stats.totaltime.should == 2
+        end
+
+        it "should calculate no responses correctly" do
+          Time.stubs(:now).returns(Time.at(1300031824))
+          @stats.time_discovery(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031825))
+          @stats.time_discovery(:end)
+
+          Time.stubs(:now).returns(Time.at(1300031826))
+          @stats.time_block_execution(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031827))
+          @stats.time_block_execution(:end)
+
+          @stats.discovered_agents(["one", "two", "three"])
+          @stats.node_responded("one")
+          @stats.node_responded("two")
+
+          @stats.finish_request
+
+          @stats.noresponsefrom.should == ["three"]
+        end
+
+        it "should recover from failure correctly" do
+          Time.stubs(:now).returns(Time.at(1300031824))
+          @stats.time_discovery(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031825))
+          @stats.time_discovery(:end)
+
+          Time.stubs(:now).returns(Time.at(1300031826))
+          @stats.time_block_execution(:start)
+
+          Time.stubs(:now).returns(Time.at(1300031827))
+          @stats.time_block_execution(:end)
+
+          # cause the .each to raise an exception
+          @stats.instance_variable_set("@responsesfrom", nil)
+          @stats.finish_request
+
+          @stats.noresponsefrom.should == []
+          @stats.totaltime.should == 0
+        end
+      end
+
+      describe "#node_responded" do
+        it "should append to the list of nodes" do
+          @stats.node_responded "foo"
+          @stats.responsesfrom.should == ["foo"]
+        end
+
+        it "should create a new array if adding fails" do
+          # cause the << to fail
+          @stats.instance_variable_set("@responsesfrom", nil)
+
+          @stats.node_responded "foo"
+          @stats.responsesfrom.should == ["foo"]
+        end
+      end
+
+      describe "#no_response_report" do
+        it "should create an empty report if all nodes responded" do
+          @stats.discovered_agents ["foo"]
+          @stats.node_responded "foo"
+          @stats.finish_request
+
+          @stats.no_response_report.should == ""
+        end
+
+        it "should list all nodes that did not respond" do
+          @stats.discovered_agents ["foo", "bar"]
+          @stats.finish_request
+
+          @stats.no_response_report.should match(Regexp.new(/No response from.+foo.+bar/m))
+        end
+      end
+    end
+  end
+end