autoscale 0.9.3 → 0.11.0

data/spec/autoscaler/binary_scaling_strategy_spec.rb

@@ -8,12 +8,12 @@ describe Autoscaler::BinaryScalingStrategy do
   it "scales with no work" do
     system = TestSystem.new(0)
     strategy = cut.new
-    strategy.call(system, 1).should == 0
+    expect(strategy.call(system, 1)).to eq 0
   end
 
   it "does not scale with pending work" do
     system = TestSystem.new(1)
     strategy = cut.new(2)
-    strategy.call(system, 1).should == 2
+    expect(strategy.call(system, 1)).to eq 2
   end
 end

data/spec/autoscaler/counter_cache_memory_spec.rb

@@ -5,17 +5,17 @@ describe Autoscaler::CounterCacheMemory do
   let(:cut) {Autoscaler::CounterCacheMemory}
 
   it {expect{cut.new.counter}.to raise_error(cut::Expired)}
-  it {cut.new.counter{1}.should == 1}
+  it {expect(cut.new.counter{1}).to eq 1}
 
   it 'set and store' do
     cache = cut.new
     cache.counter = 1
-    cache.counter.should == 1
+    expect(cache.counter).to eq 1
   end
 
   it 'times out' do
     cache = cut.new(0)
     cache.counter = 1
-    expect{cache.counter.should}.to raise_error(cut::Expired)
+    expect{cache.counter}.to raise_error(cut::Expired)
   end
 end

data/spec/autoscaler/counter_cache_redis_spec.rb

@@ -11,11 +11,11 @@ describe Autoscaler::CounterCacheRedis do
   subject {cut.new(Sidekiq.method(:redis))}
 
   it {expect{subject.counter}.to raise_error(cut::Expired)}
-  it {subject.counter{1}.should == 1}
+  it {expect(subject.counter{1}).to eq 1}
 
   it 'set and store' do
     subject.counter = 2
-    subject.counter.should == 2
+    expect(subject.counter).to eq 2
   end
 
   it 'does not conflict with multiple worker types' do
@@ -23,7 +23,7 @@ describe Autoscaler::CounterCacheRedis do
     subject.counter = 1
     other_worker_cache.counter = 2
 
-    subject.counter.should == 1
+    expect(subject.counter).to eq 1
     other_worker_cache.counter = 2
   end
 
@@ -37,13 +37,13 @@ describe Autoscaler::CounterCacheRedis do
   it 'passed a connection pool' do
     cache = cut.new(@redis)
     cache.counter = 4
-    cache.counter.should == 4
+    expect(cache.counter).to eq 4
   end
 
   it 'passed a plain connection' do
-    connection = Redis.connect(:url => 'http://localhost:9736', :namespace => 'autoscaler')
+    connection = Redis.connect(:url => 'redis://localhost:9736', :namespace => 'autoscaler')
     cache = cut.new connection
     cache.counter = 5
-    cache.counter.should == 5
+    expect(cache.counter).to eq 5
   end
 end

data/spec/autoscaler/delayed_shutdown_spec.rb

@@ -7,17 +7,17 @@ describe Autoscaler::DelayedShutdown do
 
   it "returns normal values" do
     strategy = cut.new(lambda{|s,t| 2}, 0)
-    strategy.call(nil, 1).should == 2
+    expect(strategy.call(nil, 1)).to eq 2
   end
 
   it "delays zeros" do
     strategy = cut.new(lambda{|s,t| 0}, 60)
-    strategy.call(nil, 1).should == 1
+    expect(strategy.call(nil, 1)).to eq 1
   end
 
   it "eventually returns zero" do
     strategy = cut.new(lambda{|s,t| 0}, 60)
-    strategy.stub(:level_idle_time).and_return(61)
-    strategy.call(nil, 61).should == 0
+    allow(strategy).to receive(:level_idle_time).and_return(61)
+    expect(strategy.call(nil, 61)).to eq 0
   end
 end

data/spec/autoscaler/heroku_platform_scaler_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'autoscaler/heroku_platform_scaler'
+
+describe Autoscaler::HerokuPlatformScaler, :platform_api => true do
+  let(:cut) {Autoscaler::HerokuPlatformScaler}
+  let(:client) {cut.new}
+  subject {client}
+
+  its(:workers) {should eq(0)}
+
+  describe 'scaled' do
+    around do |example|
+      client.workers = 1
+      example.call
+      client.workers = 0
+    end
+
+    its(:workers) {should eq(1)}
+  end
+
+  shared_examples 'exception handler' do |exception_class|
+    before do
+      expect(client).to receive(:client){
+        raise exception_class.new(Exception.new('oops'))
+      }
+    end
+
+    describe "default handler" do
+      it {expect{client.workers}.to_not raise_error}
+      it {expect(client.workers).to eq(0)}
+      it {expect{client.workers = 2}.to_not raise_error}
+    end
+
+    describe "custom handler" do
+      before do
+        @caught = false
+        client.exception_handler = lambda {|exception| @caught = true}
+      end
+
+      it {client.workers; expect(@caught).to be(true)}
+    end
+  end
+
+  describe 'exception handling', :focus => true do
+    it_behaves_like 'exception handler', Excon::Errors::Error
+  end
+end

data/spec/autoscaler/heroku_scaler_spec.rb

@@ -2,33 +2,33 @@ require 'spec_helper'
 require 'autoscaler/heroku_scaler'
 require 'heroku/api/errors'
 
-describe Autoscaler::HerokuScaler, :online => true do
+describe Autoscaler::HerokuScaler, :api1 => true do
   let(:cut) {Autoscaler::HerokuScaler}
   let(:client) {cut.new}
   subject {client}
 
-  its(:workers) {should == 0}
+  its(:workers) {should eq(0)}
 
   describe 'scaled' do
     around do |example|
       client.workers = 1
-      example.yield
+      example.call
       client.workers = 0
     end
 
-    its(:workers) {should == 1}
+    its(:workers) {should eq(1)}
   end
 
   shared_examples 'exception handler' do |exception_class|
     before do
-      client.should_receive(:client){
+      expect(client).to receive(:client){
         raise exception_class.new(Exception.new('oops'))
       }
     end
 
     describe "default handler" do
       it {expect{client.workers}.to_not raise_error}
-      it {client.workers.should == 0}
+      it {expect(client.workers).to eq(0)}
       it {expect{client.workers = 2}.to_not raise_error}
     end
 
@@ -38,7 +38,7 @@ describe Autoscaler::HerokuScaler, :online => true do
         client.exception_handler = lambda {|exception| @caught = true}
       end
 
-      it {client.workers; @caught.should be_true}
+      it {client.workers; expect(@caught).to be(true)}
     end
   end
 
@@ -46,4 +46,4 @@ describe Autoscaler::HerokuScaler, :online => true do
     it_behaves_like 'exception handler', Excon::Errors::SocketError
     it_behaves_like 'exception handler', Heroku::API::Errors::Error
   end
-end
+end

data/spec/autoscaler/ignore_scheduled_and_retrying_spec.rb

@@ -8,25 +8,25 @@ describe Autoscaler::IgnoreScheduledAndRetrying do
   it "passes through enqueued" do
     system = Struct.new(:enqueued).new(3)
     strategy = proc {|system, time| system.enqueued}
-    cut.new(strategy).call(system, 0).should == 3
+    expect(cut.new(strategy).call(system, 0)).to eq 3
   end
 
   it "passes through workers" do
     system = Struct.new(:workers).new(3)
     strategy = proc {|system, time| system.workers}
-    cut.new(strategy).call(system, 0).should == 3
+    expect(cut.new(strategy).call(system, 0)).to eq 3
   end
 
   it "ignores scheduled" do
     system = Struct.new(:scheduled).new(3)
     strategy = proc {|system, time| system.scheduled}
-    cut.new(strategy).call(system, 0).should == 0
+    expect(cut.new(strategy).call(system, 0)).to eq 0
   end
 
   it "ignores retrying" do
     system = Struct.new(:retrying).new(3)
     strategy = proc {|system, time| system.retrying}
-    cut.new(strategy).call(system, 0).should == 0
+    expect(cut.new(strategy).call(system, 0)).to eq 0
   end
 end
 

data/spec/autoscaler/linear_scaling_strategy_spec.rb

@@ -8,78 +8,78 @@ describe Autoscaler::LinearScalingStrategy do
   it "deactivates with no work" do
     system = TestSystem.new(0)
     strategy = cut.new(1)
-    strategy.call(system, 1).should == 0
+    expect(strategy.call(system, 1)).to eq 0
   end
 
   it "activates with some work" do
     system = TestSystem.new(1)
     strategy = cut.new(1)
-    strategy.call(system, 1).should be > 0
+    expect(strategy.call(system, 1)).to be > 0
   end
 
   it "minimally scales with minimal work" do
     system = TestSystem.new(1)
     strategy = cut.new(2, 2)
-    strategy.call(system, 1).should == 1
+    expect(strategy.call(system, 1)).to eq 1
   end
 
   it "maximally scales with too much work" do
     system = TestSystem.new(5)
     strategy = cut.new(2, 2)
-    strategy.call(system, 1).should == 2
+    expect(strategy.call(system, 1)).to eq 2
   end
 
   it "proportionally scales with some work" do
     system = TestSystem.new(5)
     strategy = cut.new(5, 2)
-    strategy.call(system, 1).should == 3
+    expect(strategy.call(system, 1)).to eq 3
   end
 
   it "doesn't scale unless minimum is met" do
     system = TestSystem.new(2)
     strategy = cut.new(10, 4, 0.5)
-    strategy.call(system, 1).should == 0
+    expect(strategy.call(system, 1)).to eq 0
   end
 
   it "scales proprotionally with a minimum" do
     system = TestSystem.new(3)
     strategy = cut.new(10, 4, 0.5)
-    strategy.call(system, 1).should == 1
+    expect(strategy.call(system, 1)).to eq 1
   end
 
   it "scales maximally with a minimum" do
     system = TestSystem.new(25)
     strategy = cut.new(5, 4, 0.5)
-    strategy.call(system, 1).should == 5
+    expect(strategy.call(system, 1)).to eq 5
   end
 
   it "scales proportionally with a minimum > 1" do
     system = TestSystem.new(12)
     strategy = cut.new(5, 4, 2)
-    strategy.call(system, 1).should == 2
+    expect(strategy.call(system, 1)).to eq 2
   end
 
   it "scales maximally with a minimum factor > 1" do
     system = TestSystem.new(30)
     strategy = cut.new(5, 4, 2)
-    strategy.call(system, 1).should == 5
+    expect(strategy.call(system, 1)).to eq 5
   end
 
   it "doesn't scale down engaged workers" do
     system = TestSystem.new(0, 2)
     strategy = cut.new(5, 4)
-    strategy.call(system, 1).should == 2
+    expect(strategy.call(system, 1)).to eq 2
   end
 
   it "doesn't scale above max workers even if engaged workers is greater" do
     system = TestSystem.new(40, 6)
     strategy = cut.new(5, 4)
-    strategy.call(system, 1).should == 5
+    expect(strategy.call(system, 1)).to eq 5
   end
 
   it "returns zero if requested capacity is zero" do
     system = TestSystem.new(0, 0)
     strategy = cut.new(0, 0)
-    strategy.call(system, 5).should == 0
+    expect(strategy.call(system, 5)).to eq 0
   end
 end

data/spec/autoscaler/sidekiq/activity_spec.rb

@@ -16,19 +16,19 @@ describe Autoscaler::Sidekiq::Activity do
       activity.idle!('queue')
       other_process.working!('other_queue')
     end
-    it {activity.should be_idle(['queue'])}
+    it {expect(activity).to be_idle(['queue'])}
   end
 
   it 'passed a connection pool' do
     activity = cut.new(5, @redis)
     activity.working!('queue')
-    activity.should_not be_idle(['queue'])
+    expect(activity).to_not be_idle(['queue'])
   end
 
   it 'passed a plain connection' do
-    connection = Redis.connect(:url => 'http://localhost:9736', :namespace => 'autoscaler')
+    connection = Redis.connect(:url => 'redis://localhost:9736', :namespace => 'autoscaler')
     activity = cut.new(5, connection)
     activity.working!('queue')
-    activity.should_not be_idle(['queue'])
+    expect(activity).to_not be_idle(['queue'])
   end
 end

data/spec/autoscaler/sidekiq/client_spec.rb

@@ -10,26 +10,26 @@ describe Autoscaler::Sidekiq::Client do
   describe 'call' do
     it 'scales' do
       client.call(Class, {}, 'queue') {}
-      scaler.workers.should == 1
+      expect(scaler.workers).to eq 1
     end
 
     it 'scales with a redis pool' do
       client.call(Class, {}, 'queue', ::Sidekiq.method(:redis)) {}
-      scaler.workers.should == 1
+      expect(scaler.workers).to eq 1
     end
 
-    it('yields') {client.call(Class, {}, 'queue') {:foo}.should == :foo}
+    it('yields') {expect(client.call(Class, {}, 'queue') {:foo}).to eq :foo}
   end
 
   describe 'initial workers' do
     it 'works with default arguments' do
       client.set_initial_workers
-      scaler.workers.should == 0
+      expect(scaler.workers).to eq 0
     end
 
     it 'scales when necessary' do
       client.set_initial_workers {|q| TestSystem.new(1)}
-      scaler.workers.should == 1
+      expect(scaler.workers).to eq 1
     end
   end
 end

data/spec/autoscaler/sidekiq/entire_queue_system_spec.rb

@@ -24,42 +24,42 @@ describe Autoscaler::Sidekiq::EntireQueueSystem do
 
   subject {cut.new}
 
-  it {subject.queue_names.should == []}
-  it {subject.workers.should == 0}
+  it {expect(subject.queue_names).to eq []}
+  it {expect(subject.workers).to eq 0}
 
   describe 'no queued work' do
     it "with no work" do
-      subject.stub(:sidekiq_queues).and_return({'queue' => 0, 'another_queue' => 0})
-      subject.queued.should == 0
+      allow(subject).to receive(:sidekiq_queues).and_return({'queue' => 0, 'another_queue' => 0})
+      expect(subject.queued).to eq 0
     end
 
     it "with no work and no queues" do
-      subject.queued.should == 0
+      expect(subject.queued).to eq 0
     end
 
     it "with no scheduled work" do
-      subject.scheduled.should == 0
+      expect(subject.scheduled).to eq 0
     end
 
     it "with no retry work" do
-      subject.retrying.should == 0
+      expect(subject.retrying).to eq 0
     end
   end
 
   describe 'with queued work' do
     it "with enqueued work" do
-      subject.stub(:sidekiq_queues).and_return({'queue' => 1})
-      subject.queued.should == 1
+      allow(subject).to receive(:sidekiq_queues).and_return({'queue' => 1})
+      expect(subject.queued).to eq 1
     end
 
     it "with schedule work" do
       with_scheduled_work_in('queue')
-      subject.scheduled.should == 1
+      expect(subject.scheduled).to eq 1
     end
 
     it "with retry work" do
       with_retry_work_in('queue')
-      subject.retrying.should == 1
+      expect(subject.retrying).to eq 1
     end
   end
 end

data/spec/autoscaler/sidekiq/sleep_wait_server_spec.rb

@@ -12,34 +12,34 @@ describe Autoscaler::Sidekiq::SleepWaitServer do
   let(:server) {cut.new(scaler, 0, ['queue'])}
 
   shared_examples "a sleepwait server" do
-  it "scales with no work" do
-    server.stub(:pending_work?).and_return(false)
-    when_run
-    scaler.workers.should == 0
-  end
+    it "scales with no work" do
+      allow(server).to receive(:pending_work?).and_return(false)
+      when_run
+      expect(scaler.workers).to eq 0
+    end
 
-  it "does not scale with pending work" do
-    server.stub(:pending_work?).and_return(true)
-    when_run
-    scaler.workers.should == 1
-  end
+    it "does not scale with pending work" do
+      allow(server).to receive(:pending_work?).and_return(true)
+      when_run
+      expect(scaler.workers).to eq 1
+    end
   end
 
   describe "a middleware with no redis specified" do
-  it_behaves_like "a sleepwait server" do
-  def when_run
-    server.call(Object.new, {}, 'queue') {}
-  end
-  end
+    it_behaves_like "a sleepwait server" do
+      def when_run
+        server.call(Object.new, {}, 'queue') {}
+      end
+    end
   end
 
   describe "a middleware with redis specified" do
-  it_behaves_like "a sleepwait server" do
-  def when_run
-    server.call(Object.new, {}, 'queue', Sidekiq.method(:redis)) {}
-  end
-  end
+    it_behaves_like "a sleepwait server" do
+      def when_run
+        server.call(Object.new, {}, 'queue', Sidekiq.method(:redis)) {}
+      end
+    end
   end
 
-  it('yields') {server.call(Object.new, {}, 'queue') {:foo}.should == :foo}
+  it('yields') {expect(server.call(Object.new, {}, 'queue') {:foo}).to eq :foo}
 end