rightscale-nanite 0.4.1.4 → 0.4.1.10

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

data/spec/log_spec.rb

@@ -1,49 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Nanite::Log do
-  describe "Using log without initializing it first" do
-    before(:each) do
-      Nanite::Log.instance_variable_set(:@logger, nil)
-    end
-    
-    it "should use standard out for logging" do
-      Nanite::Log.init
-      STDOUT.should_receive(:write) do |arg|
-        arg.include?("For your consideration").should == true
-      end
-      Nanite::Log.info("For your consideration")
-    end
-  end
-
-  describe "Initializing the log level" do
-    it "should default to :info" do
-      Nanite::Log.init
-      Nanite::Log.level.should == :info
-    end
-
-    it "should raise an error if level is incorrect" do
-      lambda { Nanite::Log.level = "fool" }.should raise_error
-    end
-
-    it "should succeed when using symbols" do
-      [ :debug, :info, :warn, :error, :fatal ].each do |level|
-        Nanite::Log.level = level
-        Nanite::Log.level.should == level
-      end
-    end
-
-
-    it "should succeed when using log levels" do
-      lvls = { Logger::DEBUG => :debug,
-               Logger::INFO  => :info,
-               Logger::WARN  => :warn,
-               Logger::ERROR => :error,
-               Logger::FATAL => :fatal }
-      lvls.keys.each do |level|
-        Nanite::Log.level = level
-        Nanite::Log.level.should == lvls[level]
-      end
-    end
-
-  end
-end

data/spec/mapper_proxy_spec.rb

@@ -1,72 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Nanite::MapperProxy do
-  describe "when fetching the instance" do
-    before(:each) do
-      if Nanite::MapperProxy.class_variables.include?('@@instance')
-        Nanite::MapperProxy.__send__(:remove_class_variable, :@@instance)
-      end
-    end
-    
-    it "should return nil when the instance is undefined" do
-      Nanite::MapperProxy.instance.should == nil
-    end
-    
-    it "should return the instance if defined" do
-      instance = mock
-      Nanite::MapperProxy.class_eval do
-        @@instance = "instance"
-      end
-      
-      Nanite::MapperProxy.instance.should_not == nil
-    end
-  end
-
-  describe "when pushing a message" do
-    before do
-      AMQP.stub!(:connect)
-      MQ.stub!(:new)
-      Nanite::MapperProxy.new('mapperproxy', {})
-      @instance = Nanite::MapperProxy.instance
-      @fanout = stub(:fanout, :publish => true)
-      @instance.amqp.stub!(:fanout).and_return(@fanout)
-    end
-    
-    it "should raise an error if mapper proxy is not initialized" do
-      lambda {
-        @instance.stub!(:identity).and_return nil
-        @instance.push('/welcome/aboard', 'iZac')
-      }.should raise_error("Mapper proxy not initialized")
-    end
-    
-    it "should set correct attributes on the push message" do
-      @fanout.should_receive(:publish).with do |push|
-        push = @instance.serializer.load(push)
-        push.token.should_not == nil
-        push.persistent.should_not == true
-        push.from.should == 'mapperproxy'
-      end
-      
-      @instance.push('/welcome/aboard', 'iZac')
-    end
-    
-    it "should mark the message as persistent when the option is specified on the parameter" do
-      @fanout.should_receive(:publish).with do |push|
-        push = @instance.serializer.load(push)
-        push.persistent.should == true
-      end
-      
-      @instance.push('/welcome/aboard', 'iZac', :persistent => true)
-    end
-    
-    it "should mark the message as persistent when the option is set globally" do
-      @instance.options[:persistent] = true
-      @fanout.should_receive(:publish).with do |push|
-        push = @instance.serializer.load(push)
-        push.persistent.should == true
-      end
-      
-      @instance.push('/welcome/aboard', 'iZac')
-    end
-  end
-end

data/spec/mapper_spec.rb

@@ -1,70 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Nanite::Mapper do
-  include SpecHelpers
-
-  describe "Initializing" do
-    before(:each) do
-      @mapper = Nanite::Mapper.new({})
-    end
-
-    it "should set the identity" do
-      @mapper.identity.should_not == nil
-      @mapper.identity.should =~ /mapper-.*/
-    end
-
-    it "should set the identity to a custom identity" do
-      @mapper = Nanite::Mapper.new({:identity => "bob"})
-      @mapper.identity.should == "mapper-bob"
-    end
-
-    it "should set the file root" do
-      @mapper.options[:file_root].should == File.expand_path("#{File.dirname(__FILE__)}/../files")
-    end
-  end
-
-  describe "Starting" do
-    before(:each) do
-      @mapper = Nanite::Mapper.new({:log_level => :debug})
-      @mapper.stub!(:setup_queues)
-      @mapper.stub!(:start_amqp)
-    end
-
-    it "should initialize the logger" do
-      @mapper.stub!(:setup_cluster)
-      run_in_em do
-        @mapper.run
-        Nanite::Log.logger.level.should == Logger::DEBUG
-      end
-    end
-
-    it "should set up the cluster" do
-      Nanite::Cluster.should_receive(:new).with(nil, 15, instance_of(String), instance_of(Nanite::Serializer), @mapper, nil, {})
-      run_in_em do
-        @mapper.run
-      end
-    end
-
-    it "should set the prefetch value" do
-      amqp = mock("AMQP")
-
-      mapper = Nanite::Mapper.new(:prefetch => 11)
-      mapper.stub!(:setup_offline_queue)
-      mapper.stub!(:setup_message_queue)
-      mapper.stub!(:start_amqp)
-      mapper.stub!(:setup_cluster)
-
-      mapper.stub!(:start_amqp).and_return(amqp)
-      amqp.should_receive(:prefetch).with(11)
-      mapper.run
-    end
-
-    it "should hand over callback options to the cluster" do
-      @mapper = Nanite::Mapper.new({:callbacks => {:register => lambda {|*args|}}})
-      @mapper.stub!(:setup_queues)
-      @mapper.stub!(:start_amqp)
-      Nanite::Cluster.should_receive(:new)
-      run_in_em {@mapper.run}
-    end
-  end
-end

data/spec/nanite_spec.rb

@@ -1,36 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Nanite do
-  describe "when ensuring a mapper exists" do
-    describe "with a configured mapper proxy" do
-      before(:each) do
-        Nanite.instance_variable_set(:@mapper, nil)
-        Nanite::MapperProxy.stub!(:instance).and_return(mock(:mapper_proxy))
-      end
-      
-      it "should not raise an error" do
-        lambda {
-          Nanite.ensure_mapper
-        }.should_not raise_error
-      end
-      
-      it "should set the mapper instance variable to the mapper proxy instance" do
-        Nanite.ensure_mapper
-        Nanite.mapper.should == Nanite::MapperProxy.instance
-      end
-    end
-    
-    describe "when the mapper wasn't started yet" do
-      before do
-        Nanite.instance_variable_set(:@mapper, nil)
-        Nanite::MapperProxy.stub!(:instance).and_return(nil)
-      end
-      
-      it "should raise an error" do
-        lambda {
-          Nanite.ensure_mapper
-        }.should raise_error(Nanite::MapperNotRunning)
-      end
-    end
-  end
-end