pause 0.4.0 → 0.5.1

data/spec/pause/action_spec.rb

@@ -11,6 +11,10 @@ describe Pause::Action do
   end
 
   let(:resolution) { 10 }
+  let(:identifier) { '11112222' }
+  let(:action) { MyNotification.new(identifier) }
+  let(:other_identifier) { '8798734' }
+  let(:other_action) { MyNotification.new(other_identifier) }
   let(:history) { 60 }
   let(:configuration) { Pause::Configuration.new }
   let(:adapter) { Pause::Redis::Adapter.new(Pause.config) }
@@ -22,15 +26,9 @@ describe Pause::Action do
     allow(Pause).to receive(:adapter).and_return(adapter)
   end
 
-  let(:identifier) { '11112222' }
-  let(:action) { MyNotification.new(identifier) }
-
-  let(:other_identifier) { '8798734' }
-  let(:other_action) { MyNotification.new(other_identifier) }
-
   RSpec.shared_examples 'an action' do
     describe '#increment!' do
-      it 'should increment' do
+      it 'increments' do
         time = Time.now
         Timecop.freeze time do
           expect(Pause.adapter).to receive(:increment).with(action.scope, identifier, time.to_i, 1)
@@ -40,7 +38,7 @@ describe Pause::Action do
     end
 
     describe '#ok?' do
-      it 'should successfully return if the action is blocked or not' do
+      it 'successfullies return if the action is blocked or not' do
         time = Time.now
         Timecop.freeze time do
           4.times do
@@ -52,7 +50,7 @@ describe Pause::Action do
         end
       end
 
-      it 'should successfully consider different period checks' do
+      it 'successfullies consider different period checks' do
         time = Time.parse('Sept 22, 11:34:00')
 
         Timecop.freeze time - 30 do
@@ -71,7 +69,7 @@ describe Pause::Action do
         end
       end
 
-      it 'should return false and silently fail if redis is not available' do
+      it 'returns false and silently fail if redis is not available' do
         allow(Pause::Logger).to receive(:fatal)
         allow_any_instance_of(Redis).to receive(:zrange).and_raise Redis::CannotConnectError
         time = period_marker(resolution, Time.now.to_i)
@@ -86,7 +84,7 @@ describe Pause::Action do
       context 'action should not be rate limited' do
         it 'returns nil' do
           expect(adapter.rate_limited?(action.scope, action.identifier)).to be false
-          expect(action.analyze).to be nil
+          expect(action.analyze).to be_nil
         end
       end
 
@@ -130,7 +128,7 @@ describe Pause::Action do
   end
 
   context 'actions under test' do
-    ['123456', 'hello', 0, 999999].each do |id|
+    ['123456', 'hello', 0, 999_999].each do |id|
       let(:identifier) { id }
       let(:action) { MyNotification.new(identifier) }
       describe "action with identifier #{id}" do
@@ -151,38 +149,47 @@ describe Pause::Action do
     let(:bogus) { Struct.new(:name, :event).new }
 
     describe '#unless_rate_limited' do
-      before do
-        expect(bogus).to receive(:name).exactly(2).times
+      before { expect(bogus).to receive(:name).twice }
+
+      describe '#initialize' do
+        before { expect(bogus).to receive(:event).once }
+
+        it 'is able to use methods inside the #new block' do
+          b = bogus
+          CowRateLimited.new(identifier) do
+            unless_rate_limited { b.name } # this executes
+            unless_rate_limited { b.name } # this also executes
+            unless_rate_limited { b.name } # and this will be rate limited
+            if_rate_limited { b.event }
+          end
+        end
       end
-      it 'should call through the block' do
+
+      it 'calls through the block' do
         action.unless_rate_limited { bogus.name }
         action.unless_rate_limited { bogus.name }
         result = action.unless_rate_limited { bogus.name }
-        expect(result).to be_a_kind_of(::Pause::RateLimitedEvent)
+        expect(result).to be_a(Pause::RateLimitedEvent)
       end
-    end
-
-    describe '#unless_rate_limited' do
-      before { expect(bogus).to receive(:name).exactly(2).times }
 
-      it 'should call through the block' do
+      it 'calls through the block' do
         3.times { action.unless_rate_limited { bogus.name } }
       end
 
       describe '#if_rate_limited' do
         before { 2.times { action.unless_rate_limited { bogus.name } } }
 
-        it 'it should not analyze during method call' do
+        it 'does not analyze during method call' do
           bogus.event = 1
           action.if_rate_limited { |event| bogus.event = event }
-          expect(bogus.event).to be_a_kind_of(::Pause::RateLimitedEvent)
+          expect(bogus.event).to be_a(Pause::RateLimitedEvent)
           expect(bogus.event.identifier).to eq(identifier)
         end
 
-        it 'should analyze if requested' do
+        it 'analyzes if requested' do
           action.unless_rate_limited { bogus.name }
           result = action.if_rate_limited { |event| bogus.event = event }
-          expect(bogus.event).to be_a_kind_of(::Pause::RateLimitedEvent)
+          expect(bogus.event).to be_a(Pause::RateLimitedEvent)
           expect(result).to eq(bogus.event)
         end
       end
@@ -190,7 +197,7 @@ describe Pause::Action do
   end
 
   describe '.tracked_identifiers' do
-    it 'should return all the identifiers tracked (but not blocked) so far' do
+    it 'returns all the identifiers tracked (but not blocked) so far' do
       action.increment!
       other_action.increment!
 
@@ -203,7 +210,7 @@ describe Pause::Action do
   end
 
   describe '.rate_limited_identifiers' do
-    it 'should return all the identifiers blocked' do
+    it 'returns all the identifiers blocked' do
       action.increment!(100, Time.now.to_i)
       other_action.increment!(100, Time.now.to_i)
 
@@ -216,7 +223,7 @@ describe Pause::Action do
   end
 
   describe '.unblock_all' do
-    it 'should unblock all the identifiers for a scope' do
+    it 'unblocks all the identifiers for a scope' do
       10.times { action.increment! }
       other_action.increment!
 
@@ -232,7 +239,6 @@ describe Pause::Action do
       expect(MyNotification.tracked_identifiers).to eq([other_action.identifier])
     end
   end
-
 end
 
 describe Pause::Action, '.check' do
@@ -250,22 +256,22 @@ describe Pause::Action, '.check' do
     check period_seconds: 50, block_ttl: 60, max_allowed: 100
   end
 
-  it 'should define a period check on new instances' do
+  it 'defines a period check on new instances' do
     expect(ActionWithCheck.new('id').checks).to eq([
                                                      Pause::PeriodCheck.new(100, 150, 200)
                                                    ])
   end
 
-  it 'should define a period check on new instances' do
+  it 'defines a period check on new instances' do
     expect(ActionWithMultipleChecks.new('id').checks).to \
       eq([
-                                                                    Pause::PeriodCheck.new(100, 150, 200),
-                                                                    Pause::PeriodCheck.new(200, 150, 200),
-                                                                    Pause::PeriodCheck.new(300, 150, 200)
-                                                                  ])
+           Pause::PeriodCheck.new(100, 150, 200),
+           Pause::PeriodCheck.new(200, 150, 200),
+           Pause::PeriodCheck.new(300, 150, 200)
+         ])
   end
 
-  it 'should accept hash arguments' do
+  it 'accepts hash arguments' do
     expect(ActionWithHashChecks.new('id').checks).to eq([
                                                           Pause::PeriodCheck.new(50, 100, 60)
                                                         ])
@@ -278,7 +284,7 @@ describe Pause::Action, '.scope' do
     end
   end
 
-  it 'should raise if scope is not defined' do
+  it 'raises if scope is not defined' do
     expect(MyApp::NoScope.new('1.2.3.4').scope).to eq 'myapp.noscope'
   end
 
@@ -286,7 +292,7 @@ describe Pause::Action, '.scope' do
     scope 'my:scope'
   end
 
-  it 'should set scope on class' do
+  it 'sets scope on class' do
     expect(DefinedScopeAction.new('1.2.3.4').scope).to eq('my:scope')
   end
 end
@@ -309,26 +315,26 @@ describe Pause::Action, 'enabled/disabled states' do
   describe '#disable' do
     before do
       expect(action).to be_enabled
-      expect(action).to_not be_disabled
+      expect(action).not_to be_disabled
       action.disable
     end
 
     it 'disables the action' do
       expect(action).to be_disabled
-      expect(action).to_not be_enabled
+      expect(action).not_to be_enabled
     end
   end
 
   describe '#enable' do
     before do
       action.disable
-      expect(action).to_not be_enabled
+      expect(action).not_to be_enabled
       action.enable
     end
 
     it 'enables the action' do
       expect(action).to be_enabled
-      expect(action).to_not be_disabled
+      expect(action).not_to be_disabled
     end
   end
 end

data/spec/pause/analyzer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'timecop'
 
@@ -11,20 +13,17 @@ describe Pause::Analyzer do
   end
 
   let(:resolution) { 10 }
+  let(:analyzer) { Pause.analyzer }
+  let(:action) { FollowPushNotification.new('1243123') }
   let(:history) { 60 }
   let(:configuration) { Pause::Configuration.new }
   let(:adapter) { Pause::Redis::Adapter.new(configuration) }
 
   before do
-    allow(Pause).to receive(:config).and_return(configuration)
-    allow(Pause.config).to receive(:resolution).and_return(resolution)
-    allow(Pause.config).to receive(:history).and_return(history)
-    allow(Pause).to receive(:adapter).and_return(adapter)
+    allow(Pause.config).to receive_messages(resolution: resolution, history: history)
+    allow(Pause).to receive_messages(config: configuration, adapter: adapter)
   end
 
-  let(:analyzer) { Pause.analyzer }
-  let(:action) { FollowPushNotification.new('1243123') }
-
   describe '#analyze' do
     it 'checks and blocks if max_allowed is reached' do
       time = Time.now
@@ -39,11 +38,15 @@ describe Pause::Analyzer do
   end
 
   describe '#check' do
-    it 'should return nil if action is NOT blocked' do
-      expect(analyzer.check(action)).to be nil
+    it 'returns nil if action is NOT blocked' do
+      expect(analyzer.check(action)).to be_nil
+    end
+
+    it 'returns nil if action is NOT rate limited' do
+      expect(action).not_to be_rate_limited
     end
 
-    it 'should return blocked action if action is blocked' do
+    it 'returns blocked action if action is blocked' do
       Timecop.freeze Time.now do
         5.times do
           action.increment!

data/spec/pause/configuration_spec.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Pause::Configuration, '#configure' do
+  subject { described_class.new }
 
-  subject { Pause::Configuration.new }
-
-  it 'should allow configuration via block' do
+  it 'allows configuration via block' do
     subject.configure do |c|
       c.redis_host = '128.23.12.8'
       c.redis_port = '2134'
@@ -24,7 +25,7 @@ describe Pause::Configuration, '#configure' do
     expect(subject.sharded).to be true
   end
 
-  it 'should provide redis defaults' do
+  it 'provides redis defaults' do
     subject.configure do |config|
       # do nothing
     end
@@ -33,7 +34,7 @@ describe Pause::Configuration, '#configure' do
     expect(subject.redis_port).to eq(6379)
     expect(subject.redis_db).to eq('1')
     expect(subject.resolution).to eq(600) # 10 minutes
-    expect(subject.history).to eq(86400) # one day
+    expect(subject.history).to eq(86_400) # one day
     expect(subject.sharded).to be false
   end
 end

data/spec/pause/logger_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Pause::Logger do
+  describe 'when accessed #puts' do
+    before do
+      expect($stdout).to receive(:puts).with('hello')
+    end
+
+    it 'calls through to puts without color' do
+      described_class.puts('hello')
+    end
+  end
+
+  describe 'when accessed via #fatal' do
+    before do
+      expect($stderr).to receive(:puts).with("\e[31mwhoops\e[0m")
+    end
+
+    it 'calls through to puts with color' do
+      described_class.fatal('whoops')
+    end
+  end
+end

data/spec/pause/pause_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Pause do
@@ -5,8 +7,8 @@ RSpec.describe Pause do
     let(:configuration) { Pause::Configuration.new }
 
     before do
-      Pause.adapter = nil
-      allow(Pause).to receive(:config).and_return(configuration)
+      described_class.adapter = nil
+      allow(described_class).to receive(:config).and_return(configuration)
       configuration.configure { |c| c.sharded = sharded }
     end
 
@@ -14,7 +16,7 @@ RSpec.describe Pause do
       let(:sharded) { true }
 
       it 'is a ShardedAdapter' do
-        expect(Pause.adapter).to be_a(Pause::Redis::ShardedAdapter)
+        expect(described_class.adapter).to be_a(Pause::Redis::ShardedAdapter)
       end
     end
 
@@ -22,7 +24,7 @@ RSpec.describe Pause do
       let(:sharded) { false }
 
       it 'is an Adapter' do
-        expect(Pause.adapter).to be_a(Pause::Redis::Adapter)
+        expect(described_class.adapter).to be_a(Pause::Redis::Adapter)
       end
     end
   end

data/spec/pause/period_check_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Pause
+  RSpec.describe PeriodCheck do
+    let(:period_seconds) { 10 }
+    let(:max_allowed) { 2 }
+    let(:block_ttl) { 10 }
+
+    let(:period_check_1) do
+      described_class.new(
+        period_seconds: period_seconds,
+        max_allowed: max_allowed,
+        block_ttl: block_ttl
+      )
+    end
+
+    let(:period_check_2) do
+      described_class.new(
+        period_seconds: 2 * period_seconds,
+        max_allowed: 1.5 * max_allowed,
+        block_ttl:
+      )
+    end
+
+    describe '#==' do
+      let(:period_check_3) do
+        described_class.new(
+          period_seconds: 2 * period_seconds,
+          max_allowed: 1.5 * max_allowed,
+          block_ttl:
+        )
+      end
+
+      it 'is equal' do
+        expect(period_check_3).to eq(period_check_2)
+      end
+
+      it 'is not equal' do
+        expect(period_check_3).not_to eq(period_check_1)
+      end
+
+      describe '#sort' do
+        let(:list) { [period_check_2, period_check_1] }
+
+        it 'sorts' do
+          expect(list.sort).to eq([period_check_1, period_check_2])
+        end
+      end
+    end
+  end
+end

data/spec/pause/redis/adapter_spec.rb

@@ -1,59 +1,82 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'date'
 require 'timecop'
 
 describe Pause::Redis::Adapter do
-
   let(:resolution) { 10 }
+  let(:adapter) { described_class.new(Pause.config) }
+  let(:redis_conn) { adapter.send(:redis) }
   let(:history) { 60 }
   let(:configuration) { Pause::Configuration.new }
 
   before do
     allow(Pause).to receive(:config).and_return(configuration)
-    allow(Pause.config).to receive(:resolution).and_return(resolution)
-    allow(Pause.config).to receive(:history).and_return(history)
+    allow(Pause.config).to receive_messages(resolution: resolution, history: history)
     redis_conn.flushall
   end
 
-  let(:adapter) { Pause::Redis::Adapter.new(Pause.config) }
-  let(:redis_conn) { adapter.send(:redis) }
-
   describe '#increment' do
     let(:scope) { 'blah' }
     let(:identifier) { '213213' }
-    let(:tracked_key) { 'i:blah:|213213|' }
+    let(:tracked_key) { "i:#{scope}:|#{identifier}|" }
+    let(:now) { Time.now.to_i }
 
-    it 'should add key to a redis set' do
+    it 'adds key to a redis set' do
       adapter.increment(scope, identifier, Time.now.to_i)
-      set = redis_conn.zrange(tracked_key, 0, -1, :with_scores => true)
-      expect(set).to_not be_empty
-      expect(set.size).to eql(1)
-      expect(set[0].size).to eql(2)
+      set = redis_conn.zrange(tracked_key, 0, -1, with_scores: true)
+      expect(set).not_to be_empty
+      expect(set.size).to be(1)
+      expect(set[0].size).to be(2)
+    end
+
+    describe 'when increment is called' do
+      let(:redis_conn_double) { instance_double(Redis) }
+
+      before do
+        allow(adapter).to receive(:with_multi).and_yield(redis_conn_double)
+      end
+
+      it 'calls zincrby on the redis connection' do
+        allow(redis_conn_double).to receive(:expire)
+        expect(redis_conn_double).to receive(:zincrby)
+
+        adapter.increment(scope, identifier, Time.now.to_i)
+      end
+
+      it 'calls expire on the redis key' do
+        expect(redis_conn_double).to receive(:expire).with(tracked_key, history)
+        allow(redis_conn_double).to receive(:zincrby)
+
+        adapter.increment(scope, identifier, Time.now.to_i)
+      end
     end
 
     context 'removing two elements' do
       let(:to_delete) { 2 }
-      let(:time) { Time.now }
+      let(:period_start) { adapter.period_marker(resolution, now) }
+      let(:period_end) { adapter.period_marker(resolution, now + resolution) }
+
+      around do |example|
+        Timecop.freeze(now) { example.run }
+      end
+
       before do
-        adapter
-        to_delete.times do |t|
-          expect(redis_conn).to receive(:zrem).with(tracked_key, [adapter.period_marker(resolution, time + t)]).once
-        end
+        redis_conn.flushall
         adapter.time_blocks_to_keep = 1
+        allow(redis_conn).to receive(:zrem).with(tracked_key, [period_start])
+        allow(redis_conn).to receive(:zrem).with(tracked_key, [period_start, period_end])
       end
-      it 'should remove old elements' do
-        adapter.increment(scope, identifier, time.to_i)
+
+      it 'removes old elements' do
+        adapter.increment(scope, identifier, now.to_i)
         to_delete.times do |t|
-          next_time = time + (adapter.resolution + t + 1)
+          next_time = now + (adapter.resolution + t + 1)
           adapter.increment(scope, identifier, next_time.to_i)
         end
       end
     end
-
-    it 'sets expiry on key' do
-      expect(redis_conn).to receive(:expire).with(tracked_key, history)
-      adapter.increment(scope, identifier, Time.now.to_i)
-    end
   end
 
   describe '#expire_block_list' do
@@ -74,21 +97,18 @@ describe Pause::Redis::Adapter do
 
       adapter.expire_block_list(scope)
 
-      expect(redis_conn.zscore('b:|a|', blocked_identifier)).not_to be nil
-      expect(redis_conn.zscore('b:|a|', expired_identifier)).to be nil
+      expect(redis_conn.zscore('b:|a|', blocked_identifier)).not_to be_nil
+      expect(redis_conn.zscore('b:|a|', expired_identifier)).to be_nil
     end
   end
 
-  describe '#rate_limit!' do
-  end
-
   describe '#rate_limited?' do
     let(:scope) { 'ipn:follow' }
     let(:identifier) { '123461234' }
     let(:blocked_key) { "b:#{key}" }
-    let(:ttl) { 110000 }
+    let(:ttl) { 110_000 }
 
-    it 'should return true if blocked' do
+    it 'returns true if blocked' do
       adapter.rate_limit!(scope, identifier, ttl)
       expect(adapter.rate_limited?(scope, identifier)).to be true
     end
@@ -128,17 +148,16 @@ describe Pause::Redis::Adapter do
       let(:scope) { 'ipn:follow' }
       let(:identifier) { '1234' }
       let(:blocked_key) { "b:|#{scope}|" }
-      let(:ttl) { 110000 }
+      let(:ttl) { 110_000 }
 
       it 'saves ip to redis with expiration' do
         time = Time.now
         Timecop.freeze time do
           adapter.rate_limit!(scope, identifier, ttl)
         end
-        expect(redis_conn.zscore(blocked_key, identifier)).to_not be nil
+        expect(redis_conn.zscore(blocked_key, identifier)).not_to be_nil
         expect(redis_conn.zscore(blocked_key, identifier)).to eq(time.to_i + ttl)
       end
-
     end
   end
 

data/spec/pause/redis/sharded_adapter_spec.rb

@@ -1,21 +1,20 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'date'
 require 'timecop'
 
 describe Pause::Redis::ShardedAdapter do
-
   let(:resolution) { 10 }
+  let(:adapter) { described_class.new(Pause.config) }
   let(:history) { 60 }
   let(:configuration) { Pause::Configuration.new }
 
   before do
     allow(Pause).to receive(:config).and_return(configuration)
-    allow(Pause.config).to receive(:resolution).and_return(resolution)
-    allow(Pause.config).to receive(:history).and_return(history)
+    allow(Pause.config).to receive_messages(resolution: resolution, history: history)
   end
 
-  let(:adapter) { Pause::Redis::ShardedAdapter.new(Pause.config) }
-
   describe '#all_keys' do
     it 'is not supported' do
       expect { adapter.all_keys('cake') }.to raise_error(Pause::Redis::OperationNotSupported)
@@ -24,15 +23,16 @@ describe Pause::Redis::ShardedAdapter do
 
   describe '#with_multi' do
     let(:redis) { adapter.send(:redis) }
-    it 'should not call redis.multi' do
-      expect(redis).to_not receive(:multi)
-      expect { adapter.increment(:scope, 123, Time.now) }.to_not raise_error
+
+    it 'does not call redis.multi' do
+      expect(redis).not_to receive(:multi)
+      expect { adapter.increment(:scope, 123, Time.now) }.not_to raise_error
     end
   end
 
   describe '#redis' do
-    it 'should not use redis db when connecting' do
-      expect(adapter.send(:redis_connection_opts)).to_not include(:db)
+    it 'does not use redis db when connecting' do
+      expect(adapter.send(:redis_connection_opts)).not_to include(:db)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # Require this file using `require "spec_helper"` to ensure that it is only
@@ -5,28 +7,30 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
-require 'pause'
 require 'fileutils'
 
+require 'simplecov'
+SimpleCov.start
+
+require 'pause'
+
 if ENV['PAUSE_REAL_REDIS']
   require 'pause/redis/adapter'
-  puts ; puts "NOTE: Using real Redis-server at #{Pause::Redis::Adapter.redis.inspect}\n\n"
+  puts
+  puts "NOTE: Using real Redis-server at #{Pause::Redis::Adapter.redis.inspect}\n\n"
 else
   require 'fakeredis/rspec'
 end
 
 RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
-  rspec_dir = './.spec'.freeze
+  rspec_dir = './.spec'
   FileUtils.mkdir_p(rspec_dir)
   config.example_status_persistence_file_path = "#{rspec_dir}/results.txt"
 
   config.order = 'random'
 
   if ENV['PAUSE_REAL_REDIS']
-    config.before(:example) do
+    config.before do
       Pause::Redis::Adapter.redis.flushdb
     end
   end