berater 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa5d51d6eea9d4691e58e8dd7065a1d596a57abdac1227fa19bd22cd2f42c15d
-  data.tar.gz: 55ac15bf6f2f295c525fdea57b3af9b518935a12dd4b644e3c0c9c085429ca50
+  metadata.gz: 87d3bdb61a68a8b69dd7cb285dafb174a403acf19ff7586f90ed8b7cb50b7f76
+  data.tar.gz: fff71dd4d8ae28baf7c504efdc27df71f03219b32c1a959dddfd3d035845d058
 SHA512:
-  metadata.gz: 52df5781f9c37c7f1c9dde09e579c8da1f2d62f405835b771c6087cda8af046018e85a88629f7c5d3a2be9aafd2680e348d1b2f91bc63fe456e6e51ec5d0fd02
-  data.tar.gz: '0928cb6f2e8e07810dec96f5af302ff9f62d519b9f19ef6f28acb5621569f13edb6d784cbd7084b738df8dfc232ace26e3ce0c6c4a7f2ac3e4391c97789bafae'
+  metadata.gz: c9fb5c0c7ec100d2f50a3b6c6cfa449af052c1b78cff174b545e179c5fcc1324c2a5faafc90e7f7ec64ce200e47571d51b02eb56398d716c487abc7731c0cece
+  data.tar.gz: 148c566413d6593f229143e2871116b45947eae5b101d8bb2f59ce3bdfe89ed4ee1b7aaedfcaedbc80eef8a25a14fab83ad5e540172c41f31f27d7f296161235

data/lib/berater/concurrency_limiter.rb

@@ -14,7 +14,7 @@ module Berater
     private def timeout=(timeout)
       @timeout = timeout
       timeout = 0 if timeout == Float::INFINITY
-      @timeout_usec = Berater::Utils.to_usec(timeout)
+      @timeout_msec = Berater::Utils.to_msec(timeout)
     end
 
     LUA_SCRIPT = Berater::LuaScript(<<~LUA
@@ -65,24 +65,29 @@ module Berater
 
     def limit(capacity: nil, cost: 1, &block)
       capacity ||= @capacity
-      # cost is Integer >= 0
 
-      # timestamp in microseconds
-      ts = (Time.now.to_f * 10**6).to_i
+      # since fractional cost is not supported, capacity behaves like int
+      capacity = capacity.to_i
+
+      unless cost.is_a?(Integer) && cost >= 0
+        raise ArgumentError, "invalid cost: #{cost}"
+      end
+
+      # timestamp in milliseconds
+      ts = (Time.now.to_f * 10**3).to_i
 
       count, *lock_ids = LUA_SCRIPT.eval(
         redis,
         [ cache_key(key), cache_key('lock_id') ],
-        [ capacity, ts, @timeout_usec, cost ]
+        [ capacity, ts, @timeout_msec, cost ]
       )
 
       raise Incapacitated if lock_ids.empty?
 
-      if cost == 0
-        lock = Lock.new(self, nil, count)
-      else
-        lock = Lock.new(self, lock_ids[0], count, -> { release(lock_ids) })
+      release_fn = if cost > 0
+        proc { release(lock_ids) }
       end
+      lock = Lock.new(capacity, count, release_fn)
 
       yield_lock(lock, &block)
     end

data/lib/berater/limiter.rb

@@ -47,11 +47,15 @@ module Berater
     end
 
     def capacity=(capacity)
-      unless capacity.is_a?(Integer) || capacity == Float::INFINITY
-        raise ArgumentError, "expected Integer, found #{capacity.class}"
+      unless capacity.is_a?(Numeric)
+        raise ArgumentError, "expected Numeric, found #{capacity.class}"
       end
 
-      raise ArgumentError, "capacity must be >= 0" unless capacity >= 0
+      if capacity == Float::INFINITY
+        raise ArgumentError, 'infinite capacity not supported, use Unlimiter'
+      end
+
+      raise ArgumentError, 'capacity must be >= 0' unless capacity >= 0
 
       @capacity = capacity
     end

data/lib/berater/lock.rb

@@ -1,11 +1,10 @@
 module Berater
   class Lock
 
-    attr_reader :limiter, :id, :contention
+    attr_reader :capacity, :contention
 
-    def initialize(limiter, id, contention, release_fn = nil)
-      @limiter = limiter
-      @id = id
+    def initialize(capacity, contention, release_fn = nil)
+      @capacity = capacity
       @contention = contention
       @locked_at = Time.now
       @release_fn = release_fn

data/lib/berater/rate_limiter.rb

@@ -7,12 +7,16 @@ module Berater
 
     def initialize(key, capacity, interval, **opts)
       self.interval = interval
-      super(key, capacity, @interval_usec, **opts)
+      super(key, capacity, @interval_msec, **opts)
     end
 
     private def interval=(interval)
       @interval = interval
-      @interval_usec = Berater::Utils.to_usec(interval)
+      @interval_msec = Berater::Utils.to_msec(interval)
+
+      unless @interval_msec > 0
+        raise ArgumentError, 'interval must be > 0'
+      end
     end
 
     LUA_SCRIPT = Berater::LuaScript(<<~LUA
@@ -20,11 +24,11 @@ module Berater
       local ts_key = KEYS[2]
       local ts = tonumber(ARGV[1])
       local capacity = tonumber(ARGV[2])
-      local interval_usec = tonumber(ARGV[3])
+      local interval_msec = tonumber(ARGV[3])
       local cost = tonumber(ARGV[4])
       local count = 0
       local allowed
-      local usec_per_drip = interval_usec / capacity
+      local msec_per_drip = interval_msec / capacity
 
       -- timestamp of last update
       local last_ts = tonumber(redis.call('GET', ts_key))
@@ -33,7 +37,7 @@ module Berater
         count = tonumber(redis.call('GET', key)) or 0
 
         -- adjust for time passing
-        local drips = math.floor((ts - last_ts) / usec_per_drip)
+        local drips = math.floor((ts - last_ts) / msec_per_drip)
         count = math.max(0, count - drips)
       end
 
@@ -47,7 +51,7 @@ module Berater
           count = count + cost
 
           -- time for bucket to empty, in milliseconds
-          local ttl = math.ceil((count * usec_per_drip) / 1000)
+          local ttl = math.ceil(count * msec_per_drip)
 
           -- update count and last_ts, with expirations
           redis.call('SET', key, count, 'PX', ttl)
@@ -62,18 +66,18 @@ module Berater
     def limit(capacity: nil, cost: 1, &block)
       capacity ||= @capacity
 
-      # timestamp in microseconds
-      ts = (Time.now.to_f * 10**6).to_i
+      # timestamp in milliseconds
+      ts = (Time.now.to_f * 10**3).to_i
 
       count, allowed = LUA_SCRIPT.eval(
         redis,
         [ cache_key(key), cache_key("#{key}-ts") ],
-        [ ts, capacity, @interval_usec, cost ]
+        [ ts, capacity, @interval_msec, cost ]
       )
 
       raise Overrated unless allowed
 
-      lock = Lock.new(self, ts, count)
+      lock = Lock.new(capacity, count)
       yield_lock(lock, &block)
     end
 

data/lib/berater/rspec.rb

@@ -4,7 +4,7 @@ require 'berater/test_mode'
 require 'rspec'
 
 RSpec.configure do |config|
-  config.include(BeraterMatchers)
+  config.include(Berater::Matchers)
 
   config.after do
     Berater.expunge rescue nil

data/lib/berater/rspec/matchers.rb

@@ -1,62 +1,83 @@
-module BeraterMatchers
-  class Overloaded
-    def initialize(type)
-      @type = type
-    end
+module Berater
+  module Matchers
+    class Overloaded
+      def initialize(type)
+        @type = type
+      end
 
-    def supports_block_expectations?
-      true
-    end
+      def supports_block_expectations?
+        true
+      end
+
+      def matches?(obj)
+        begin
+          case obj
+          when Proc
+            # eg. expect { ... }.to be_overrated
+            res = obj.call
 
-    def matches?(obj)
-      begin
-        case obj
-        when Proc
-          # eg. expect { ... }.to be_overrated
-          res = obj.call
-
-          if res.is_a? Berater::Limiter
-            # eg. expect { Berater.new(...) }.to be_overloaded
-            res.overloaded?
-          else
-            # eg. expect { Berater(...)  }.to be_overloaded
-            # eg. expect { limiter.limit }.to be_overloaded
-            false
+            if res.is_a? Berater::Limiter
+              # eg. expect { Berater.new(...) }.to be_overloaded
+              @limiter = res
+              res.overloaded?
+            else
+              # eg. expect { Berater(...)  }.to be_overloaded
+              # eg. expect { limiter.limit }.to be_overloaded
+              false
+            end
+          when Berater::Limiter
+            # eg. expect(Berater.new(...)).to be_overloaded
+            @limiter = obj
+            obj.overloaded?
           end
-        when Berater::Limiter
-          # eg. expect(Berater.new(...)).to be_overloaded
-          obj.overloaded?
+        rescue @type
+          true
         end
-      rescue @type
-        true
       end
-    end
 
-    # def description
-    # it { expect { Berater.new(:inhibitor) }.not_to be_overrated }
+      def description
+        if @limiter
+          "be #{verb}"
+        else
+          "raise #{@type}"
+        end
+      end
 
-    def failure_message
-      "expected #{@type} to be raised"
-    end
+      def failure_message
+        if @limiter
+          "expected to be #{verb}"
+        else
+          "expected #{@type} to be raised"
+        end
+      end
 
-    def failure_message_when_negated
-      "did not expect #{@type} to be raised"
+      def failure_message_when_negated
+        if @limiter
+          "expected not to be #{verb}"
+        else
+          "did not expect #{@type} to be raised"
+        end
+      end
+
+      private def verb
+        @type.to_s.split('::')[-1].downcase
+      end
     end
-  end
 
-  def be_overloaded
-    Overloaded.new(Berater::Overloaded)
-  end
+    def be_overloaded
+      Overloaded.new(Berater::Overloaded)
+    end
 
-  def be_overrated
-    Overloaded.new(Berater::RateLimiter::Overrated)
-  end
+    def be_overrated
+      Overloaded.new(Berater::RateLimiter::Overrated)
+    end
 
-  def be_incapacitated
-    Overloaded.new(Berater::ConcurrencyLimiter::Incapacitated)
-  end
+    def be_incapacitated
+      Overloaded.new(Berater::ConcurrencyLimiter::Incapacitated)
+    end
 
-  def be_inhibited
-    Overloaded.new(Berater::Inhibitor::Inhibited)
+    def be_inhibited
+      Overloaded.new(Berater::Inhibitor::Inhibited)
+    end
   end
 end

data/lib/berater/unlimiter.rb

@@ -6,12 +6,16 @@ module Berater
     end
 
     def limit(**opts, &block)
-      yield_lock(Lock.new(self, Float::INFINITY, 0), &block)
+      yield_lock(Lock.new(Float::INFINITY, 0), &block)
     end
 
     def overloaded?
       false
     end
 
+    protected def capacity=(*)
+      @capacity = Float::INFINITY
+    end
+
   end
 end

data/lib/berater/utils.rb

@@ -3,12 +3,12 @@ module Berater
     extend self
 
     refine Object do
-      def to_usec
-        Berater::Utils.to_usec(self)
+      def to_msec
+        Berater::Utils.to_msec(self)
       end
     end
 
-    def to_usec(val)
+    def to_msec(val)
       res = val
 
       if val.is_a? String
@@ -39,7 +39,7 @@ module Berater
         raise ArgumentError, "infinite values not allowed"
       end
 
-      (res * 10**6).to_i
+      (res * 10**3).to_i
     end
 
   end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/spec/concurrency_limiter_spec.rb

@@ -23,6 +23,7 @@ describe Berater::ConcurrencyLimiter do
 
     it { expect_capacity(0) }
     it { expect_capacity(1) }
+    it { expect_capacity(1.5) }
     it { expect_capacity(10_000) }
 
     context 'with erroneous values' do
@@ -32,7 +33,6 @@ describe Berater::ConcurrencyLimiter do
         end.to raise_error ArgumentError
       end
 
-      it { expect_bad_capacity(0.5) }
       it { expect_bad_capacity(-1) }
       it { expect_bad_capacity('1') }
       it { expect_bad_capacity(:one) }
@@ -42,16 +42,16 @@ describe Berater::ConcurrencyLimiter do
   describe '#timeout' do
     # see spec/utils_spec.rb
 
-    it 'saves the interval in original and microsecond format' do
+    it 'saves the interval in original and millisecond format' do
       limiter = described_class.new(:key, 1, timeout: 3)
       expect(limiter.timeout).to be 3
-      expect(limiter.instance_variable_get(:@timeout_usec)).to be (3 * 10**6)
+      expect(limiter.instance_variable_get(:@timeout_msec)).to be (3 * 10**3)
     end
 
     it 'handles infinity' do
       limiter = described_class.new(:key, 1, timeout: Float::INFINITY)
       expect(limiter.timeout).to be Float::INFINITY
-      expect(limiter.instance_variable_get(:@timeout_usec)).to be 0
+      expect(limiter.instance_variable_get(:@timeout_msec)).to be 0
     end
   end
 
@@ -88,6 +88,18 @@ describe Berater::ConcurrencyLimiter do
       end
     end
 
+    context 'when capacity is a Float' do
+      let(:limiter) { described_class.new(:key, 1.5) }
+
+      it 'still works' do
+        lock = limiter.limit
+
+        # since fractional cost is not supported
+        expect(lock.capacity).to be 1
+        expect(limiter).to be_incapacitated
+      end
+    end
+
     it 'limit resets over time' do
       2.times { limiter.limit }
       expect(limiter).to be_incapacitated
@@ -149,6 +161,11 @@ describe Berater::ConcurrencyLimiter do
         5.times { limiter.limit(capacity: 10) }
         expect { limiter }.to be_incapacitated
       end
+
+      it 'only allows positive, Integer values' do
+        expect { limiter.limit(cost: -1) }.to raise_error(ArgumentError)
+        expect { limiter.limit(cost: 1.5) }.to raise_error(ArgumentError)
+      end
     end
 
     context 'with same key, different limiters' do

data/spec/matchers_spec.rb

@@ -1,4 +1,5 @@
-describe 'be_overloaded' do
+describe Berater::Matchers::Overloaded do
+
   context 'Berater::Unlimiter' do
     let(:limiter) { Berater.new(:key, :unlimited) }
 
@@ -16,12 +17,6 @@ describe 'be_overloaded' do
     it { expect { limiter.limit }.not_to be_inhibited }
     it { expect { limiter.limit }.not_to be_overrated }
     it { expect { limiter.limit }.not_to be_incapacitated }
-
-    it 'catches false positives' do
-      expect {
-        expect { limiter }.to be_overloaded
-      }.to fail
-    end
   end
 
   context 'Berater::Inhibitor' do
@@ -35,12 +30,6 @@ describe 'be_overloaded' do
 
     it { expect { limiter.limit }.to be_overloaded }
     it { expect { limiter.limit }.to be_inhibited }
-
-    it 'catches false negatives' do
-      expect {
-        expect { limiter }.not_to be_overloaded
-      }.to fail
-    end
   end
 
   context 'Berater::RateLimiter' do
@@ -127,4 +116,71 @@ describe 'be_overloaded' do
       end
     end
   end
+
+  context 'when matchers fail' do
+    let(:unlimiter) { Berater::Unlimiter.new }
+    let(:inhibitor) { Berater::Inhibitor.new }
+
+    it 'catches false negatives' do
+      expect {
+        expect(unlimiter).to be_overloaded
+      }.to fail_including('expected to be overloaded')
+
+      expect {
+        expect { unlimiter }.to be_overloaded
+      }.to fail_including('expected to be overloaded')
+
+      expect {
+        expect { unlimiter.limit }.to be_overloaded
+      }.to fail_including("expected #{Berater::Overloaded} to be raised")
+
+      expect {
+        expect { 123 }.to be_overloaded
+      }.to fail_including("expected #{Berater::Overloaded} to be raised")
+    end
+
+    it 'catches false positives' do
+      expect {
+        expect(inhibitor).not_to be_overloaded
+      }.to fail_including('expected not to be overloaded')
+
+      expect {
+        expect { inhibitor }.not_to be_overloaded
+      }.to fail_including('expected not to be overloaded')
+
+      expect {
+        expect { inhibitor.limit }.not_to be_overloaded
+      }.to fail_including("did not expect #{Berater::Overloaded} to be raised")
+
+      expect {
+        expect { raise Berater::Overloaded }.not_to be_overloaded
+      }.to fail_including("did not expect #{Berater::Overloaded} to be raised")
+    end
+
+    it 'supports different verbs' do
+      expect {
+        expect { unlimiter }.to be_overrated
+      }.to fail_including('expected to be overrated')
+
+      expect {
+        expect { unlimiter }.to be_incapacitated
+      }.to fail_including('expected to be incapacitated')
+    end
+
+    it 'supports different exceptions' do
+      expect {
+        expect { 123 }.to be_overrated
+      }.to fail_including(
+        "expected #{Berater::RateLimiter::Overrated} to be raised"
+      )
+
+      expect {
+        expect {
+          raise Berater::ConcurrencyLimiter::Incapacitated
+        }.not_to be_incapacitated
+      }.to fail_including(
+        "did not expect #{Berater::ConcurrencyLimiter::Incapacitated} to be raised"
+      )
+    end
+  end
 end

data/spec/rate_limiter_spec.rb

@@ -23,6 +23,7 @@ describe Berater::RateLimiter do
 
     it { expect_capacity(0) }
     it { expect_capacity(1) }
+    it { expect_capacity(1.5) }
     it { expect_capacity(100) }
 
     context 'with erroneous values' do
@@ -32,7 +33,6 @@ describe Berater::RateLimiter do
         end.to raise_error ArgumentError
       end
 
-      it { expect_bad_capacity(0.5) }
       it { expect_bad_capacity(-1) }
       it { expect_bad_capacity('1') }
       it { expect_bad_capacity(:one) }
@@ -44,9 +44,19 @@ describe Berater::RateLimiter do
 
     subject { described_class.new(:key, 1, :second) }
 
-    it 'saves the interval in original and microsecond format' do
+    it 'saves the interval in original and millisecond format' do
       expect(subject.interval).to be :second
-      expect(subject.instance_variable_get(:@interval_usec)).to be 10**6
+      expect(subject.instance_variable_get(:@interval_msec)).to be 10**3
+    end
+
+    it 'must be > 0' do
+      expect {
+        described_class.new(:key, 1, 0)
+      }.to raise_error(ArgumentError)
+
+      expect {
+        described_class.new(:key, 1, -1)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -68,26 +78,57 @@ describe Berater::RateLimiter do
       expect(limiter).to be_overrated
     end
 
-    it 'limit resets over time, with millisecond precision' do
+    it 'resets limit over time' do
       3.times { limiter.limit }
       expect(limiter).to be_overrated
 
-      # travel forward to just before the count decrements
-      Timecop.freeze(0.333)
-      expect(limiter).to be_overrated
-
-      # traveling one more millisecond will decrement the count
-      Timecop.freeze(0.001)
-      limiter.limit
-      expect(limiter).to be_overrated
-
-      # traveling 1 second will reset the count
       Timecop.freeze(1)
 
       3.times { limiter.limit }
       expect(limiter).to be_overrated
     end
 
+    context 'with millisecond precision' do
+      it 'resets limit over time' do
+        3.times { limiter.limit }
+        expect(limiter).to be_overrated
+
+        # travel forward to just before the count decrements
+        Timecop.freeze(0.333)
+        expect(limiter).to be_overrated
+
+        # traveling one more millisecond will decrement the count
+        Timecop.freeze(0.001)
+        limiter.limit
+        expect(limiter).to be_overrated
+      end
+
+      it 'works when drip rate is < 1 per millisecond' do
+        limiter = described_class.new(:key, 2_000, :second)
+
+        limiter.capacity.times { limiter.limit }
+        expect(limiter).to be_overrated
+
+        Timecop.freeze(0.001)
+        expect(limiter).not_to be_overrated
+
+        2.times { limiter.limit }
+      end
+    end
+
+    context 'when capacity is a Float' do
+      let(:limiter) { described_class.new(:key, 1.5, :second) }
+
+      it 'still works' do
+        limiter.limit
+        expect(limiter).not_to be_overrated
+
+        expect { limiter.limit }.to be_overrated
+
+        limiter.limit(cost: 0.5)
+      end
+    end
+
     it 'accepts a dynamic capacity' do
       limiter = described_class.new(:key, 1, :second)
 

data/spec/test_mode_spec.rb

@@ -172,20 +172,11 @@ describe Berater::TestMode, order: :defined do
   describe 'ConcurrencyLimiter' do
     subject { Berater::ConcurrencyLimiter.new(:key, 1) }
 
-    shared_examples 'a ConcurrencyLimiter' do
-      it { expect(subject).to be_a Berater::ConcurrencyLimiter }
-
-      it 'checks arguments' do
-        expect {
-          Berater::ConcurrencyLimiter.new(:key, 1.0)
-        }.to raise_error(ArgumentError)
-      end
-    end
-
     context 'when test_mode = nil' do
       before { Berater.test_mode = nil }
 
-      it_behaves_like 'a ConcurrencyLimiter'
+      it { is_expected.to be_a Berater::ConcurrencyLimiter }
+
       it_behaves_like 'it is not overloaded'
 
       it 'works per usual' do
@@ -198,14 +189,16 @@ describe Berater::TestMode, order: :defined do
     context 'when test_mode = :pass' do
       before { Berater.test_mode = :pass }
 
-      it_behaves_like 'a ConcurrencyLimiter'
+      it { is_expected.to be_a Berater::ConcurrencyLimiter }
+
       it_behaves_like 'it always works, without redis'
     end
 
     context 'when test_mode = :fail' do
       before { Berater.test_mode = :fail }
 
-      it_behaves_like 'a ConcurrencyLimiter'
+      it { is_expected.to be_a Berater::ConcurrencyLimiter }
+
       it_behaves_like 'it never works, without redis'
     end
   end

data/spec/utils_spec.rb

@@ -1,63 +1,63 @@
 describe Berater::Utils do
   using Berater::Utils
 
-  describe '.to_usec' do
+  describe '.to_msec' do
     def f(val)
-      (val * 10**6).to_i
+      (val * 10**3).to_i
     end
 
     it 'works with integers' do
-      expect(0.to_usec).to be f(0)
-      expect(3.to_usec).to be f(3)
+      expect(0.to_msec).to be f(0)
+      expect(3.to_msec).to be f(3)
     end
 
     it 'works with floats' do
-      expect(0.1.to_usec).to be f(0.1)
-      expect(3.0.to_usec).to be f(3)
+      expect(0.1.to_msec).to be f(0.1)
+      expect(3.0.to_msec).to be f(3)
     end
 
-    it 'has great precision' do
-      expect(0.123456.to_usec).to be 123456
-      expect(123456.654321.to_usec).to be 123456654321
+    it 'truncates excessive precision' do
+      expect(0.123456.to_msec).to be 123
+      expect(123456.654321.to_msec).to be 123456654
     end
 
     it 'works with symbols that are keywords' do
-      expect(:sec.to_usec).to be f(1)
-      expect(:second.to_usec).to be f(1)
-      expect(:seconds.to_usec).to be f(1)
+      expect(:sec.to_msec).to be f(1)
+      expect(:second.to_msec).to be f(1)
+      expect(:seconds.to_msec).to be f(1)
 
-      expect(:min.to_usec).to be f(60)
-      expect(:minute.to_usec).to be f(60)
-      expect(:minutes.to_usec).to be f(60)
+      expect(:min.to_msec).to be f(60)
+      expect(:minute.to_msec).to be f(60)
+      expect(:minutes.to_msec).to be f(60)
 
-      expect(:hour.to_usec).to be f(60 * 60)
-      expect(:hours.to_usec).to be f(60 * 60)
+      expect(:hour.to_msec).to be f(60 * 60)
+      expect(:hours.to_msec).to be f(60 * 60)
     end
 
     it 'works with strings that are keywords' do
-      expect('sec'.to_usec).to be f(1)
-      expect('second'.to_usec).to be f(1)
-      expect('seconds'.to_usec).to be f(1)
+      expect('sec'.to_msec).to be f(1)
+      expect('second'.to_msec).to be f(1)
+      expect('seconds'.to_msec).to be f(1)
 
-      expect('min'.to_usec).to be f(60)
-      expect('minute'.to_usec).to be f(60)
-      expect('minutes'.to_usec).to be f(60)
+      expect('min'.to_msec).to be f(60)
+      expect('minute'.to_msec).to be f(60)
+      expect('minutes'.to_msec).to be f(60)
 
-      expect('hour'.to_usec).to be f(60 * 60)
-      expect('hours'.to_usec).to be f(60 * 60)
+      expect('hour'.to_msec).to be f(60 * 60)
+      expect('hours'.to_msec).to be f(60 * 60)
     end
 
     it 'works with strings that are numeric' do
-      expect('0'.to_usec).to be f(0)
-      expect('3'.to_usec).to be f(3)
+      expect('0'.to_msec).to be f(0)
+      expect('3'.to_msec).to be f(3)
 
-      expect('0.1'.to_usec).to be f(0.1)
-      expect('3.0'.to_usec).to be f(3)
+      expect('0.1'.to_msec).to be f(0.1)
+      expect('3.0'.to_msec).to be f(3)
     end
 
     context 'with erroneous values' do
       def e(val)
-        expect { val.to_usec }.to raise_error(ArgumentError)
+        expect { val.to_msec }.to raise_error(ArgumentError)
       end
 
       it 'rejects negative numbers' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-06 00:00:00.000000000 Z
+date: 2021-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis