ezmobius-nanite 0.4.0 → 0.4.1.1

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,219 @@
+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 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 log debug message about message to be processed" do
+      Nanite::Log.should_receive(:debug)
+      @warden.process(@message)
+    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

data/spec/packet_spec.rb

@@ -0,0 +1,218 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Packet: Base class" do
+  before(:all) do
+    class TestPacket < Nanite::Packet
+      @@cls_attr = "ignore"
+      def initialize(attr1)
+        @attr1 = attr1
+      end
+    end
+  end
+
+  it "should be an abstract class" do
+    lambda { Nanite::Packet.new }.should raise_error(NotImplementedError, "Nanite::Packet is an abstract class.")
+  end
+
+  it "should know how to dump itself to JSON" do
+    packet = TestPacket.new(1)
+    packet.should respond_to(:to_json)
+  end
+
+  it "should dump the class name in 'json_class' JSON key" do
+    packet = TestPacket.new(42)
+    packet.to_json().should =~ /\"json_class\":\"TestPacket\"/
+  end
+
+  it "should dump instance variables in 'data' JSON key" do
+    packet = TestPacket.new(188)
+    packet.to_json().should =~ /\"data\":\{\"attr1\":188\}/
+  end
+
+  it "should not dump class variables" do
+    packet = TestPacket.new(382)
+    packet.to_json().should_not =~ /cls_attr/
+  end
+
+  it "should store instance variables in 'data' JSON key as JSON object" do
+    packet = TestPacket.new(382)
+    packet.to_json().should =~ /\"data\":\{[\w:"]+\}/
+  end
+
+  it "should remove '@' from instance variables" do
+    packet = TestPacket.new(2)
+    packet.to_json().should_not =~ /@attr1/
+    packet.to_json().should =~ /attr1/
+  end
+end
+
+
+describe "Packet: FileStart" do
+  it "should dump/load as JSON objects" do
+    packet = Nanite::FileStart.new('foo.txt', 'somewhere/foo.txt', '0xdeadbeef')
+    packet2 = JSON.parse(packet.to_json)
+    packet.filename.should == packet2.filename
+    packet.dest.should == packet2.dest
+    packet.token.should == packet2.token
+  end
+
+  it "should dump/load as Marshalled ruby objects" do
+    packet = Nanite::FileStart.new('foo.txt', 'somewhere/foo.txt', '0xdeadbeef')
+    packet2 = Marshal.load(Marshal.dump(packet))
+    packet.filename.should == packet2.filename
+    packet.dest.should == packet2.dest
+    packet.token.should == packet2.token
+  end
+end
+
+
+describe "Packet: FileEnd" do
+  it "should dump/load as JSON objects" do
+    packet = Nanite::FileEnd.new('0xdeadbeef', 'metadata')
+    packet2 = JSON.parse(packet.to_json)
+    packet.meta.should == packet2.meta
+    packet.token.should == packet2.token
+  end
+
+  it "should dump/load as Marshalled ruby objects" do
+    packet = Nanite::FileEnd.new('0xdeadbeef', 'metadata')
+    packet2 = Marshal.load(Marshal.dump(packet))
+    packet.meta.should == packet2.meta
+    packet.token.should == packet2.token
+  end
+end
+
+
+describe "Packet: FileChunk" do
+  it "should dump/load as JSON objects" do
+    packet = Nanite::FileChunk.new('chunk','0xdeadbeef')
+    packet2 = JSON.parse(packet.to_json)
+    packet.chunk.should == packet2.chunk
+    packet.token.should == packet2.token
+  end
+
+  it "should dump/load as Marshalled ruby objects" do
+    packet = Nanite::FileChunk.new('chunk','0xdeadbeef')
+    packet2 = Marshal.load(Marshal.dump(packet))
+    packet.chunk.should == packet2.chunk
+    packet.token.should == packet2.token
+  end
+end
+
+
+describe "Packet: Request" do
+  it "should dump/load as JSON objects" do
+    packet = Nanite::Request.new('/some/foo', 'payload', :from => 'from', :token => '0xdeadbeef', :reply_to => 'reply_to')
+    packet2 = JSON.parse(packet.to_json)
+    packet.type.should == packet2.type
+    packet.payload.should == packet2.payload
+    packet.from.should == packet2.from
+    packet.token.should == packet2.token
+    packet.reply_to.should == packet2.reply_to
+  end
+
+  it "should dump/load as Marshalled ruby objects" do
+    packet = Nanite::Request.new('/some/foo', 'payload', :from => 'from', :token => '0xdeadbeef', :reply_to => 'reply_to')
+    packet2 = Marshal.load(Marshal.dump(packet))
+    packet.type.should == packet2.type
+    packet.payload.should == packet2.payload
+    packet.from.should == packet2.from
+    packet.token.should == packet2.token
+    packet.reply_to.should == packet2.reply_to
+  end
+end
+
+
+describe "Packet: Result" do
+  it "should dump/load as JSON objects" do
+    packet = Nanite::Result.new('0xdeadbeef', 'to', 'results', 'from')
+    packet2 = JSON.parse(packet.to_json)
+    packet.token.should == packet2.token
+    packet.to.should == packet2.to
+    packet.results.should == packet2.results
+    packet.from.should == packet2.from
+  end
+
+  it "should dump/load as Marshalled ruby objects" do
+    packet = Nanite::Result.new('0xdeadbeef', 'to', 'results', 'from')
+    packet2 = Marshal.load(Marshal.dump(packet))
+    packet.token.should == packet2.token
+    packet.to.should == packet2.to
+    packet.results.should == packet2.results
+    packet.from.should == packet2.from
+  end
+end
+
+
+describe "Packet: IntermediateMessage" do
+  it "should dump/load as JSON objects" do
+    packet = Nanite::IntermediateMessage.new('0xdeadbeef', 'to', 'from', 'messagekey', 'message')
+    packet2 = JSON.parse(packet.to_json)
+    packet.token.should == packet2.token
+    packet.to.should == packet2.to
+    packet.from.should == packet2.from
+    packet.messagekey.should == packet2.messagekey
+    packet.message.should == packet2.message
+  end
+
+  it "should dump/load as Marshalled ruby objects" do
+    packet = Nanite::IntermediateMessage.new('0xdeadbeef', 'to', 'from', 'messagekey', 'message')
+    packet2 = Marshal.load(Marshal.dump(packet))
+    packet.token.should == packet2.token
+    packet.to.should == packet2.to
+    packet.from.should == packet2.from
+    packet.messagekey.should == packet2.messagekey
+    packet.message.should == packet2.message
+  end
+end
+
+
+describe "Packet: Register" do
+  it "should dump/load as JSON objects" do
+    packet = Nanite::Register.new('0xdeadbeef', ['/foo/bar', '/nik/qux'], 0.8, ['foo'])
+    packet2 = JSON.parse(packet.to_json)
+    packet.identity.should == packet2.identity
+    packet.services.should == packet2.services
+    packet.status.should == packet2.status
+  end
+
+  it "should dump/load as Marshalled ruby objects" do
+    packet = Nanite::Register.new('0xdeadbeef', ['/foo/bar', '/nik/qux'], 0.8, ['foo'])
+    packet2 = Marshal.load(Marshal.dump(packet))
+    packet.identity.should == packet2.identity
+    packet.services.should == packet2.services
+    packet.status.should == packet2.status
+  end
+end
+
+
+describe "Packet: UnRegister" do
+  it "should dump/load as JSON objects" do
+    packet = Nanite::UnRegister.new('0xdeadbeef')
+    packet2 = JSON.parse(packet.to_json)
+    packet.identity.should == packet2.identity
+  end
+
+  it "should dump/load as Marshalled ruby objects" do
+    packet = Nanite::UnRegister.new('0xdeadbeef')
+    packet2 = Marshal.load(Marshal.dump(packet))
+    packet.identity.should == packet2.identity
+  end
+end
+
+
+describe "Packet: Ping" do
+  it "should dump/load as JSON objects" do
+    packet = Nanite::Ping.new('0xdeadbeef', 0.8)
+    packet2 = JSON.parse(packet.to_json)
+    packet.identity.should == packet2.identity
+    packet.status.should == packet2.status
+  end
+
+  it "should dump/load as Marshalled ruby objects" do
+    packet = Nanite::Ping.new('0xdeadbeef', 0.8)
+    packet2 = Marshal.load(Marshal.dump(packet))
+    packet.identity.should == packet2.identity
+    packet.status.should == packet2.status
+  end
+end