nofxx-nanite 0.4.1.2

data/spec/dispatcher_spec.rb

@@ -0,0 +1,136 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+class Foo
+  include Nanite::Actor
+  expose :bar, :index, :i_kill_you
+  on_exception :handle_exception
+
+  def index(payload)
+    bar(payload)
+  end
+
+  def bar(payload)
+    ['hello', payload]
+  end
+  
+  def bar2(payload, deliverable)
+    deliverable
+  end
+
+  def i_kill_you(payload)
+    raise RuntimeError.new('I kill you!')
+  end
+
+  def handle_exception(method, deliverable, error)
+  end
+end
+
+class Bar
+  include Nanite::Actor
+  expose :i_kill_you
+  on_exception do |method, deliverable, error|
+    @scope = self
+    @called_with = [method, deliverable, error]
+  end
+
+  def i_kill_you(payload)
+    raise RuntimeError.new('I kill you!')
+  end
+end
+
+# No specs, simply ensures multiple methods for assigning on_exception callback,
+# on_exception raises exception when called with an invalid argument.
+class Doomed
+  include Nanite::Actor
+  on_exception do
+  end
+  on_exception lambda {}
+  on_exception :doh
+end
+
+# Mock the EventMachine deferrer.
+class EMMock
+  def self.defer(op = nil, callback = nil)
+    callback.call(op.call)
+  end
+end
+
+describe "Nanite::Dispatcher" do
+
+  before(:each) do
+    Nanite::Log.stub!(:info)
+    Nanite::Log.stub!(:error)
+    amq = mock('amq', :queue => mock('queue', :publish => nil))
+    @actor = Foo.new
+    @registry = Nanite::ActorRegistry.new
+    @registry.register(@actor, nil)
+    @dispatcher = Nanite::Dispatcher.new(amq, @registry, Nanite::Serializer.new(:marshal), '0xfunkymonkey', {})
+    @dispatcher.evmclass = EMMock
+  end
+
+  it "should dispatch a request" do
+    req = Nanite::Request.new('/foo/bar', 'you')
+    res = @dispatcher.dispatch(req)
+    res.should(be_kind_of(Nanite::Result))
+    res.token.should == req.token
+    res.results.should == ['hello', 'you']
+  end
+
+  it "should dispatch the deliverable to actions that accept it" do
+    req = Nanite::Request.new('/foo/bar2', 'you')
+    res = @dispatcher.dispatch(req)
+    res.should(be_kind_of(Nanite::Result))
+    res.token.should == req.token
+    res.results.should == req
+  end
+  
+  it "should dispatch a request to the default action" do
+    req = Nanite::Request.new('/foo', 'you')
+    res = @dispatcher.dispatch(req)
+    res.should(be_kind_of(Nanite::Result))
+    res.token.should == req.token
+    res.results.should == ['hello', 'you']
+  end
+
+  it "should handle custom prefixes" do
+    @registry.register(Foo.new, 'umbongo')
+    req = Nanite::Request.new('/umbongo/bar', 'you')
+    res = @dispatcher.dispatch(req)
+    res.should(be_kind_of(Nanite::Result))
+    res.token.should == req.token
+    res.results.should == ['hello', 'you']
+  end
+
+  it "should call the on_exception callback if something goes wrong" do
+    req = Nanite::Request.new('/foo/i_kill_you', nil)
+    @actor.should_receive(:handle_exception).with(:i_kill_you, req, duck_type(:exception, :backtrace))
+    @dispatcher.dispatch(req)
+  end
+
+  it "should call on_exception Procs defined in a subclass with the correct arguments" do
+    actor = Bar.new
+    @registry.register(actor, nil)
+    req = Nanite::Request.new('/bar/i_kill_you', nil)
+    @dispatcher.dispatch(req)
+    called_with = actor.instance_variable_get("@called_with")
+    called_with[0].should == :i_kill_you
+    called_with[1].should == req
+    called_with[2].should be_kind_of(RuntimeError)
+    called_with[2].message.should == 'I kill you!'
+  end
+
+  it "should call on_exception Procs defined in a subclass in the scope of the actor" do
+    actor = Bar.new
+    @registry.register(actor, nil)
+    req = Nanite::Request.new('/bar/i_kill_you', nil)
+    @dispatcher.dispatch(req)
+    actor.instance_variable_get("@scope").should == actor
+  end
+
+  it "should log error if something goes wrong" do
+    Nanite::Log.should_receive(:error)
+    req = Nanite::Request.new('/foo/i_kill_you', nil)
+    @dispatcher.dispatch(req)
+  end
+
+end # Nanite::Dispatcher

data/spec/distinguished_name_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Nanite::DistinguishedName do
+
+  before(:all) do
+    test_dn = { 'C'  => 'US',
+                'ST' => 'California',
+                'L'  => 'Santa Barbara',
+                'O'  => 'RightScale',
+                'OU' => 'Certification Services',
+                'CN' => 'rightscale.com/emailAddress=cert@rightscale.com' }
+    @dn = Nanite::DistinguishedName.new(test_dn)
+  end
+
+  it 'should convert to string and X509 DN' do
+    @dn.to_s.should_not be_nil
+    @dn.to_x509.should_not be_nil
+  end
+
+  it 'should correctly encode' do
+    @dn.to_s.should == @dn.to_x509.to_s
+  end
+
+end

data/spec/encrypted_document_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Nanite::EncryptedDocument do
+  
+  include SpecHelpers
+
+  before(:all) do
+    @test_data = "Test Data to Sign"
+    @cert, @key = issue_cert
+    @doc = Nanite::EncryptedDocument.new(@test_data, @cert)
+  end
+
+  it 'should create encrypted data' do
+    @doc.encrypted_data.should_not be_nil
+  end
+
+  it 'should decrypt correctly' do
+    @doc.decrypted_data(@key, @cert).should == @test_data
+  end
+
+end

data/spec/job_spec.rb

@@ -0,0 +1,251 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Nanite::JobWarden do
+
+  describe "Creating a new Job" do
+
+    before(:each) do
+      @serializer = mock("Serializer")
+      @warden = Nanite::JobWarden.new(@serializer)
+
+      @request = mock("Request")
+      @targets = mock("Targets")
+      @job = mock("Job", :token => "3faba24fcc")
+    end
+
+    it "should instantiate a new Job" do
+      Nanite::Job.should_receive(:new).with(@request, @targets, nil, nil).and_return(@job)
+      @warden.new_job(@request, @targets)
+    end
+
+    it "should add the job to the job list" do
+      Nanite::Job.should_receive(:new).with(@request, @targets, nil, nil).and_return(@job)
+      @warden.jobs.size.should == 0
+      @warden.new_job(@request, @targets)
+      @warden.jobs.size.should == 1
+      @warden.jobs["3faba24fcc"].should == @job
+    end
+
+    it "return the newly crated job" do
+      Nanite::Job.should_receive(:new).with(@request, @targets, nil, nil).and_return(@job)
+      @warden.new_job(@request, @targets).should == @job
+    end
+
+  end # Creating a new Job
+
+  describe "Processing an intermediate message" do
+    before(:each) do
+      @intm_handler = lambda {|arg1, arg2, arg3| puts 'ehlo'}
+      @message = mock("Message", :token => "3faba24fcc", :from => 'nanite-agent')
+      @serializer = mock("Serializer", :load => @message)
+      @warden = Nanite::JobWarden.new(@serializer)
+      @job = Nanite::Job.new(stub("request", :token => "3faba24fcc"), [], @intm_handler)
+      @job.instance_variable_set(:@pending_keys, ["defaultkey"])
+      @job.instance_variable_set(:@intermediate_state, {"nanite-agent" => {"defaultkey" => [1]}})
+      @warden.jobs[@job.token] = @job
+      Nanite::Log.stub!(:debug)
+      Nanite::Log.stub!(:error)
+    end
+    
+    it "should call the intermediate handler with three parameters" do
+      @intm_handler.should_receive(:call).with("defaultkey", "nanite-agent", 1)
+      @warden.process(@message)
+    end
+    
+    it "should call the intermediate handler with four parameters" do
+      @intm_handler.stub!(:arity).and_return(4)
+      @intm_handler.should_receive(:call).with("defaultkey", "nanite-agent", 1, @job)
+      @warden.process(@message)
+    end
+    
+    it "should not call the intermediate handler when it can't be found for the specified key" do
+      @intm_handler.should_not_receive(:call)
+      @job.instance_variable_set(:@intermediate_handler, nil)
+      @warden.process(@message)
+    end
+    
+    it "should call the intermediate handler with one parameter which needs to be the result" do
+      @intm_handler.should_receive(:call).with(1, @job)
+      @intm_handler.stub!(:arity).and_return(2)
+      @warden.process(@message)
+    end
+  end
+  
+  describe "Processing a Message" do
+
+    before(:each) do
+      @message = mock("Message", :token => "3faba24fcc")
+      @warden = Nanite::JobWarden.new(@serializer)
+      @job = mock("Job", :token => "3faba24fcc", :process => true, :completed? => false, :results => 42, :pending_keys => [], :intermediate_handler => true)
+
+      Nanite::Log.stub!(:debug)
+    end
+
+    it "should hand over processing to job" do
+      Nanite::Job.stub!(:new).and_return(@job)
+      @job.should_receive(:process).with(@message)
+
+      @warden.new_job("request", "targets")
+      @warden.process(@message)
+    end
+
+    it "should delete job from jobs after completion" do
+      Nanite::Job.stub!(:new).and_return(@job)
+      @job.should_receive(:process).with(@message)
+      @job.should_receive(:completed?).and_return(true)
+      @job.should_receive(:completed).and_return(nil)
+
+      @warden.jobs["3faba24fcc"].should be_nil
+      @warden.new_job("request", "targets")
+      @warden.jobs["3faba24fcc"].should == @job
+      @warden.process(@message)
+      @warden.jobs["3faba24fcc"].should be_nil
+    end
+
+    it "should call completed block after completion" do
+      completed_block = mock("Completed", :arity => 1, :call => true)
+
+      Nanite::Job.stub!(:new).and_return(@job)
+      @job.should_receive(:process).with(@message)
+      @job.should_receive(:completed?).and_return(true)
+      @job.should_receive(:completed).exactly(3).times.and_return(completed_block)
+
+      @warden.new_job("request", "targets")
+      @warden.process(@message)
+    end
+
+    it "should pass in job result if arity of completed block is one" do
+      completed_block = mock("Completed")
+
+      Nanite::Job.stub!(:new).and_return(@job)
+      @job.should_receive(:process).with(@message)
+      @job.should_receive(:completed?).and_return(true)
+      @job.should_receive(:completed).exactly(3).times.and_return(completed_block)
+      @job.should_receive(:results).and_return("the job result")
+      completed_block.should_receive(:arity).and_return(1)
+      completed_block.should_receive(:call).with("the job result")
+
+      @warden.new_job("request", "targets")
+      @warden.process(@message)
+    end
+
+    it "should pass in job result and job if arity of completed block is two" do
+      completed_block = mock("Completed")
+
+      Nanite::Job.stub!(:new).and_return(@job)
+      @job.should_receive(:process).with(@message)
+      @job.should_receive(:completed?).and_return(true)
+      @job.should_receive(:completed).exactly(3).times.and_return(completed_block)
+      @job.should_receive(:results).and_return("the job result")
+      completed_block.should_receive(:arity).and_return(2)
+      completed_block.should_receive(:call).with("the job result", @job)
+
+      @warden.new_job("request", "targets")
+      @warden.process(@message)
+    end
+
+  end # Processing a Message
+
+end # Nanite::JobWarden
+
+
+describe Nanite::Job do
+
+  describe "Creating a Job" do
+
+    before(:each) do
+      @request = mock("Request", :token => "af534ceaaacdcd")
+    end
+
+    it "should initialize the request" do
+      job = Nanite::Job.new(@request, nil, nil)
+      job.request.should == @request
+    end
+
+    it "should initialize the targets" do
+      job = Nanite::Job.new(@request, "targets", nil)
+      job.targets.should == "targets"
+    end
+
+    it "should initialize the job token to the request token" do
+      job = Nanite::Job.new(@request, nil, nil)
+      job.token.should == "af534ceaaacdcd"
+    end
+
+    it "should initialize the results to an empty hash" do
+      job = Nanite::Job.new(@request, nil, nil)
+      job.results.should == {}
+    end
+
+    it "should initialize the intermediate state to an empty hash" do
+      job = Nanite::Job.new(@request, nil, nil)
+      job.intermediate_state.should == {}
+    end
+
+    it "should initialize the job block" do
+      job = Nanite::Job.new(@request, nil, nil, "my block")
+      job.completed.should == "my block"
+    end
+
+  end # Creating a new Job
+
+
+  describe "Processing a Message" do
+
+    before(:each) do
+      @request = mock("Request", :token => "feeefe132")
+    end
+
+    it "should set the job result (for sender) to the message result for 'final' status messages" do
+      job = Nanite::Job.new(@request, [], nil)
+      message = Nanite::Result.new('token', 'to', 'results', 'from')
+      job.results.should == {}
+      job.process(message)
+      job.results.should == { 'from' => 'results' }
+    end
+
+    it "should delete the message sender from the targets for 'final' status messages" do
+      job = Nanite::Job.new(@request, ['from'], nil)
+      message = Nanite::Result.new('token', 'to', 'results', 'from')
+      job.targets.should == ['from']
+      job.process(message)
+      job.targets.should == []
+    end
+
+    it "should set the job result (for sender) to the message result for 'intermediate' status messages" do
+      job = Nanite::Job.new(@request, ['from'], nil)
+      message = Nanite::IntermediateMessage.new('token', 'to', 'from', 'messagekey', 'message')
+      job.process(message)
+      job.intermediate_state.should == { 'from' => { 'messagekey' => ['message'] } }
+    end
+
+    it "should not delete the message sender from the targets for 'intermediate' status messages" do
+      job = Nanite::Job.new(@request, ['from'], nil)
+      message = Nanite::IntermediateMessage.new('token', 'to', 'from', 'messagekey', 'message')
+      job.targets.should == ['from']
+      job.process(message)
+      job.targets.should == ['from']
+    end
+
+  end # Processing a Message
+
+
+  describe "Completion" do
+
+    before(:each) do
+      @request = mock("Request", :token => "af534ceaaacdcd")
+    end
+
+    it "should be true is targets are empty" do
+      job = Nanite::Job.new(@request, {}, nil)
+      job.completed?.should == true
+    end
+
+    it "should be false is targets are not empty" do
+      job = Nanite::Job.new(@request, { :a => 1 }, nil)
+      job.completed?.should == false
+    end
+
+  end # Completion
+
+end # Nanite::Job

data/spec/local_state_spec.rb

@@ -0,0 +1,112 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'nanite/local_state'
+
+describe "Nanite::LocalState: " do
+
+  describe "Class" do
+
+    it "should a Hash" do
+      Nanite::LocalState.new({}).should be_kind_of(Hash)
+    end
+
+    it "should create empty hash if no hash passed in" do
+      Nanite::LocalState.new.should == {}
+    end
+
+    it "should initialize hash with value passed in" do
+      state = Nanite::LocalState.new({:a => 1, :b => 2, :c => 3})
+      state.should == {:a => 1, :b => 2, :c => 3}
+    end
+
+  end # Class
+
+
+  describe "All services" do
+
+    it "should return empty array if no services are defined" do
+      state = Nanite::LocalState.new({:f => { :foo => 1 }, :b => { :bar => 2 }})
+      state.all_services.should == []
+    end
+
+    it "should return all :services values" do
+      state = Nanite::LocalState.new({:f => { :foo => 1 }, :b => { :services => "b's services" }, :c => { :services => "c's services" }})
+      state.all_services.should include("b's services")
+      state.all_services.should include("c's services")
+    end
+
+    it "should only return one entry for each service" do
+      state = Nanite::LocalState.new({:f => { :services => "services" }, :b => { :services => "services" }})
+      state.all_services.size == 1
+      state.all_services.should == ["services"]
+    end
+
+  end # All services
+
+
+  describe "All tags" do
+
+    it "should return empty array if no tags are defined" do
+      state = Nanite::LocalState.new({:f => { :foo => 1 }, :b => { :bar => 2 }})
+      state.all_tags.should == []
+    end
+
+    it "should return all :tags values" do
+      state = Nanite::LocalState.new({:f => { :foo => 1 }, :b => { :tags => ["a", "b"] }, :c => { :tags => ["c", "d"] }})
+      state.all_tags.should include("a")
+      state.all_tags.should include("b")
+      state.all_tags.should include("c")
+      state.all_tags.should include("d")
+    end
+
+    it "should only return one entry for each tag" do
+      state = Nanite::LocalState.new({:f => { :foo => 1 }, :b => { :tags => ["a", "b"] }, :c => { :tags => ["a", "c"] }})
+      state.all_tags.size == 3
+      state.all_tags.should include("a")
+      state.all_tags.should include("b")
+      state.all_tags.should include("c")
+    end
+
+  end # All tags
+
+
+  describe "Nanites lookup" do
+
+    it "should find services matching the service criteria if no tags criteria is specified" do
+      state = Nanite::LocalState.new({:a => { :services => "a's services" }, :b => { :services => "b's services" }})
+      state.nanites_for("b's services").should == [[:b, {:services => "b's services"}]]
+    end
+
+    it "should find all services matching the service criteria if no tags criteria is specified" do
+      state = Nanite::LocalState.new({:a => { :services => "services" }, :b => { :services => "services" }, :c => { :services => "other services" }})
+      state.nanites_for("services").should include([:a, {:services => "services"}])
+      state.nanites_for("services").should include([:b, {:services => "services"}])
+    end
+
+    it "should only services matching the service criteria that also match the tags criteria" do
+      state = Nanite::LocalState.new({:a => { :services => "a's services", :tags => ["a_1", "a_2"] }, :b => { :services => "b's services", :tags => ["b_1", "b_2"] }})
+      state.nanites_for("b's services").should == [[:b, {:tags=>["b_1", "b_2"], :services=>"b's services"}]]
+    end
+
+    it "should also return all tags for services matching the service criteria that also match a single tags criterium" do
+      state = Nanite::LocalState.new({:a => { :services => "services", :tags => ["t_1", "t_2"] }})
+      state.nanites_for("services", ["t_1"]).should == [[:a, {:tags=>["t_1", "t_2"], :services=>"services"}]]
+    end
+
+    it "should return services matching the service criteria and also match the tags criterium" do
+      state = Nanite::LocalState.new({:a => { :services => "a's services", :tags => ["a_1", "a_2"] }, :b => { :services => "b's services", :tags => ["b_1", "b_2"] }})
+      state.nanites_for("b's services", ["b_1"]).should == [[:b, {:tags=>["b_1", "b_2"], :services=>"b's services"}]]
+    end
+
+    it "should ignore services matching the service criteria and but not the tags criteria" do
+      state = Nanite::LocalState.new({:a => { :services => "services", :tags => ["t_1", "t_2"] }, :b => { :services => "services", :tags => ["t_3", "t_4"] }})
+      state.nanites_for("services", ["t_1"]).should == [[:a, {:services => "services", :tags => ["t_1", "t_2"]}]]
+    end
+
+    it "should lookup services matching the service criteria and and any of the tags criteria" do
+      state = Nanite::LocalState.new({'a' => { :services => "services", :tags => ["t_1", "t_2"] }, 'b' => { :services => "services", :tags => ["t_2", "t_3"] }})
+      state.nanites_for("services", ["t_1", "t_3"]).sort.should == [['a', {:services => "services", :tags => ["t_1", "t_2"]}], ['b', {:services => "services", :tags => ["t_2", "t_3"]}]]
+    end
+
+  end # Nanites lookup
+
+end # Nanite::LocalState