nofxx-nanite 0.4.1.2 → 0.4.1.15

data/spec/dispatcher_spec.rb

@@ -1,136 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,251 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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