resque-restriction 0.3.0 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9262042b42b7838c1b204a900d56f13263afb3d5
+  data.tar.gz: 3fd139447714181f6b99a7f2ad484a5ad70461c9
+SHA512:
+  metadata.gz: 3058d61e4310002f6d2e5f6c5f85c6e7b830507138852e8fdfbc99d5a2f68b8467d63df2ea8a516cec09100e3cc00db1a13ad7e5a1976bec199b1516fc00ddff
+  data.tar.gz: 74d9ddcb8677d8c0ea764d8b9bae61e702aabec26e548e83546725a6cac5f38afdba12dbd3f9b3660e3052dfaca51117827cf88a892ccadf5de0f0f354b3f5ec

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+### Unreleased
+
+# 0.4.0
+* release for Rails>=4.2 with ActiveJob
+
+# 0.3.0
+* release for Rails<4.2

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,116 @@
+PATH
+  remote: .
+  specs:
+    resque-restriction (0.4.0)
+      activejob
+      jeweler
+      mocha
+      resque
+      rspec
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activejob (4.2.0)
+      activesupport (= 4.2.0)
+      globalid (>= 0.3.0)
+    activesupport (4.2.0)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.3.6)
+    builder (3.2.2)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.2.5)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    git (1.2.9.1)
+    github_api (0.12.4)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.4)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 3.4)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.6)
+      oauth2
+    globalid (0.3.3)
+      activesupport (>= 4.1.0)
+    hashie (3.4.2)
+    highline (1.6.21)
+    i18n (0.7.0)
+    jeweler (2.0.1)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+    json (1.8.3)
+    jwt (1.0.0)
+    metaclass (0.0.4)
+    mini_portile (0.6.1)
+    minitest (5.7.0)
+    mocha (1.1.0)
+      metaclass (~> 0.0.1)
+    mono_logger (1.1.0)
+    multi_json (1.11.2)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    oauth2 (1.0.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.6.0)
+    rack-protection (1.5.3)
+      rack
+    rake (10.4.2)
+    rdoc (4.1.0)
+    redis (3.2.1)
+    redis-namespace (1.5.1)
+      redis (~> 3.0, >= 3.0.4)
+    resque (1.25.2)
+      mono_logger (~> 1.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.3)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    sinatra (1.4.5)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    thread_safe (0.3.5)
+    tilt (1.4.1)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  resque-restriction!
+
+BUNDLED WITH
+   1.10.3

data/README.markdown

@@ -41,16 +41,17 @@ You can also add customized restriction as you like. For example, we have a job
 
 	class GenerateFacebookShares < Resque::Plugins::RestrictionJob
 	  restrict :per_day => 40
-    
+
 	  def self.restriction_identifier(options)
 	    [self.to_s, options["user_id"]].join(":")
 	  end
-    
+
 	  #rest of your class here
 	end
 
 options["user_id"] returns the user's facebook uid, the key point is that the different restriction_identifiers can restrict different job execution numbers.
 
+
 Contributing
 ------------
 
@@ -70,6 +71,8 @@ Contributors
 ------------
 Matt Conway :: matt@conwaysplace.com :: @mattconway
 
+Martin Fourcade :: fourcade.m@gmail.com :: @mfourcade
+
 Copyright
 ---------
 Copyright (c) 2010 Richard Huang. See LICENSE for details.

data/Rakefile

@@ -1,23 +1,9 @@
 require 'rake'
-require 'spec/rake/spectask'
-require 'rake/rdoctask'
+require 'rspec/core/rake_task'
 
-desc 'Default: run unit tests.'
-task :default => :spec
-
-desc 'Generate documentation for the resque-restriction plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'resque_restriction'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+RSpec::Core::RakeTask.new(:spec)
 
-desc "Run all specs in spec directory"
-Spec::Rake::SpecTask.new(:spec) do |t|
-  t.spec_files = FileList['spec/**/*_spec.rb']
-end
+task :default => :spec
 
 begin
   require 'jeweler'

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/resque-restriction/job.rb

@@ -2,7 +2,7 @@ module Resque
   class Job
     class <<self
       alias_method :origin_reserve, :reserve
-      
+
       def reserve(queue)
         if queue =~ /^#{Plugins::Restriction::RESTRICTION_QUEUE_PREFIX}/
           # If processing the restriction queue, when poping and pushing to end,
@@ -14,7 +14,7 @@ module Resque
             # and return
             payload = Resque.pop(queue)
             if payload
-              if ! constantize(payload['class']).repush(*payload['args'])
+              if !Object.const_get(payload['class']).repush(*payload['args'])
                 return new(queue, payload)
               end
             end

data/lib/resque-restriction/restriction_job.rb

@@ -1,5 +1,8 @@
+require 'active_job'
+
 module Resque
   module Plugins
+
     module Restriction
       SECONDS = {
         :per_minute => 60,
@@ -28,7 +31,6 @@ module Resque
           # if we get a 0 result back, the key wasn't set, so we know we are
           # already tracking the count for that period'
           period_active = ! Resque.redis.setnx(key, number.to_i - 1)
-
           # If we are already tracking that period, then decrement by one to
           # see if we are allowed to run, pushing to restriction queue to run
           # later if not.  Note that the value stored is the number of outstanding
@@ -44,6 +46,9 @@ module Resque
               Resque.push restriction_queue_name, :class => to_s, :args => args
               raise Resque::Job::DontPerform
             end
+          else
+            # This is the first time we set the key, so we mark it to expire
+            mark_restriction_key_to_expire_for(key, period)
           end
         end
       end
@@ -73,16 +78,12 @@ module Resque
         self.to_s
       end
 
-      def restriction_queue_name
-        queue_name = Resque.queue_from_class(self)
-        "#{RESTRICTION_QUEUE_PREFIX}_#{queue_name}"
-      end
 
       def seconds(period)
         if SECONDS.keys.include? period
           SECONDS[period]
         else
-          period.to_s =~ /^per_(\d+)$/ and $1
+          period.to_s =~ /^per_(\d+)$/ and $1.to_i
         end
       end
 
@@ -106,11 +107,30 @@ module Resque
         end
       end
 
+      def mark_restriction_key_to_expire_for(key, period)
+        Resque.redis.expire(key, seconds(period)) unless period == :concurrent
+      end
     end
 
-    class RestrictionJob
+    class RestrictionJob < ActiveJob::Base
       extend Restriction
-    end
 
+      before_perform do |job|
+        self.class.before_perform_restriction(*job.arguments)
+      end
+
+      after_perform do |job|
+        self.class.after_perform_restriction(*job.arguments)
+      end
+
+      rescue_from(StandardError) do |err|
+        self.class.on_failure_restriction(err, *self.arguments)
+      end
+
+      def self.restriction_queue_name
+        queue_name = self.new.queue_name
+        "#{Resque::Plugins::Restriction::RESTRICTION_QUEUE_PREFIX}_#{queue_name}"
+      end
+    end
   end
 end

data/resque-restriction.gemspec

@@ -1,61 +1,58 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: resque-restriction 0.4.0 ruby lib
 
 Gem::Specification.new do |s|
-  s.name = %q{resque-restriction}
-  s.version = "0.3.0"
+  s.name = "resque-restriction"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Richard Huang"]
-  s.date = %q{2010-11-04}
-  s.description = %q{resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time, the exceeded jobs will be executed at the next period.}
-  s.email = %q{flyerhzm@gmail.com}
+  s.date = "2015-10-19"
+  s.description = "resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time, the exceeded jobs will be executed at the next period."
+  s.email = "flyerhzm@gmail.com"
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.markdown"
+    "README.markdown"
   ]
   s.files = [
-    ".gitignore",
-     ".rvmrc.example",
-     "LICENSE",
-     "README.markdown",
-     "Rakefile",
-     "VERSION",
-     "init.rb",
-     "lib/resque-restriction.rb",
-     "lib/resque-restriction/job.rb",
-     "lib/resque-restriction/restriction_job.rb",
-     "rails/init.rb",
-     "resque-restriction.gemspec",
-     "spec/redis-test.conf",
-     "spec/resque-restriction/job_spec.rb",
-     "spec/resque-restriction/restriction_job_spec.rb",
-     "spec/spec.opts",
-     "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/flyerhzm/resque-restriction}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time.}
-  s.test_files = [
+    "CHANGELOG.md",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "init.rb",
+    "lib/resque-restriction.rb",
+    "lib/resque-restriction/job.rb",
+    "lib/resque-restriction/restriction_job.rb",
+    "rails/init.rb",
+    "resque-restriction.gemspec",
+    "spec/redis-test.conf",
     "spec/resque-restriction/job_spec.rb",
-     "spec/resque-restriction/restriction_job_spec.rb",
-     "spec/spec_helper.rb"
+    "spec/resque-restriction/restriction_job_spec.rb",
+    "spec/spec_helper.rb"
   ]
+  s.homepage = "http://github.com/flyerhzm/resque-restriction"
+  s.rubygems_version = "2.4.8"
+  s.summary = "resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time."
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<resque-restriction>, [">= 0"])
       s.add_runtime_dependency(%q<resque>, [">= 1.7.0"])
     else
+      s.add_dependency(%q<resque-restriction>, [">= 0"])
       s.add_dependency(%q<resque>, [">= 1.7.0"])
     end
   else
+    s.add_dependency(%q<resque-restriction>, [">= 0"])
     s.add_dependency(%q<resque>, [">= 1.7.0"])
   end
 end

data/spec/redis-test.conf

@@ -112,7 +112,7 @@ databases 16
 # Glue small output buffers together in order to send small replies in a
 # single TCP packet. Uses a bit more CPU but most of the times it is a win
 # in terms of number of queries per second. Use 'yes' if unsure.
-glueoutputbuf yes
+# glueoutputbuf yes
 
 # Use object sharing. Can save a lot of memory if you have many common
 # string in your dataset, but performs lookups against the shared objects

data/spec/resque-restriction/job_spec.rb

@@ -1,37 +1,37 @@
-require File.join(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
 
-describe Resque::Job do
-  before(:each) do
+RSpec.describe Resque::Job do
+  before(:example) do
     Resque.redis.flushall
   end
 
   it "should repush restriction queue when reserve" do
     Resque.push('restriction_normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
-    Resque::Job.reserve('restriction_normal').should == Resque::Job.new('restriction_normal', {'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
-    Resque::Job.reserve('restriction_normal').should be_nil
-    Resque::Job.reserve('normal').should be_nil
+    expect(Resque::Job.reserve('restriction_normal')).to eq Resque::Job.new('restriction_normal', {'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
+    expect(Resque::Job.reserve('restriction_normal')).to be_nil
+    expect(Resque::Job.reserve('normal')).to be_nil
   end
 
   it "should push back to restriction queue when still restricted" do
     Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), -1)
     Resque.push('restriction_normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
-    Resque::Job.reserve('restriction_normal').should be_nil
-    Resque.pop('restriction_normal').should == {'class' => 'OneHourRestrictionJob', 'args' => ['any args']}
-    Resque::Job.reserve('normal').should be_nil
+    expect(Resque::Job.reserve('restriction_normal')).to be_nil
+    expect(Resque.pop('restriction_normal')).to eq({'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
+    expect(Resque::Job.reserve('normal')).to be_nil
   end
 
   it "should not repush when reserve normal queue" do
     Resque.push('normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
-    Resque::Job.reserve('normal').should == Resque::Job.new('normal', {'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
-    Resque::Job.reserve('normal').should be_nil
-    Resque::Job.reserve('restriction_normal').should be_nil
+    expect(Resque::Job.reserve('normal')).to eq Resque::Job.new('normal', {'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
+    expect(Resque::Job.reserve('normal')).to be_nil
+    expect(Resque::Job.reserve('restriction_normal')).to be_nil
   end
 
   it "should only push back queue_length times to restriction queue" do
     Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), -1)
     3.times { Resque.push('restriction_normal', :class => 'OneHourRestrictionJob', :args => ['any args']) }
-    Resque.size('restriction_normal').should == 3
-    OneHourRestrictionJob.should_receive(:repush).exactly(3).times.and_return(true)
+    expect(Resque.size('restriction_normal')).to eq 3
+    expect(OneHourRestrictionJob).to receive(:repush).exactly(3).times.and_return(true)
     Resque::Job.reserve('restriction_normal')
   end
 

data/spec/resque-restriction/restriction_job_spec.rb

@@ -1,124 +1,220 @@
-require File.join(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
 
-describe Resque::Plugins::RestrictionJob do
-  it "should follow the convention" do
+RSpec.describe Resque::Plugins::RestrictionJob do
+  skip "should follow the convention" do
     Resque::Plugin.lint(Resque::Plugins::RestrictionJob)
   end
 
   context "redis_key" do
     it "should get redis_key with different period" do
-      Resque::Plugins::RestrictionJob.redis_key(:per_minute).should == "Resque::Plugins::RestrictionJob:#{Time.now.to_i / 60}"
-      Resque::Plugins::RestrictionJob.redis_key(:per_hour).should == "Resque::Plugins::RestrictionJob:#{Time.now.to_i / (60*60)}"
-      Resque::Plugins::RestrictionJob.redis_key(:per_day).should == "Resque::Plugins::RestrictionJob:#{Time.now.to_i / (24*60*60)}"
-      Resque::Plugins::RestrictionJob.redis_key(:per_month).should == "Resque::Plugins::RestrictionJob:#{Date.today.strftime("%Y-%m")}"
-      Resque::Plugins::RestrictionJob.redis_key(:per_year).should == "Resque::Plugins::RestrictionJob:#{Date.today.year}"
+      expect(Resque::Plugins::RestrictionJob.redis_key(:per_minute)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / 60}"
+      expect(Resque::Plugins::RestrictionJob.redis_key(:per_hour)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / (60*60)}"
+      expect(Resque::Plugins::RestrictionJob.redis_key(:per_day)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / (24*60*60)}"
+      expect(Resque::Plugins::RestrictionJob.redis_key(:per_month)).to eq "Resque::Plugins::RestrictionJob:#{Date.today.strftime("%Y-%m")}"
+      expect(Resque::Plugins::RestrictionJob.redis_key(:per_year)).to eq "Resque::Plugins::RestrictionJob:#{Date.today.year}"
     end
 
     it "should accept customization" do
-      Resque::Plugins::RestrictionJob.redis_key(:per_1800).should == "Resque::Plugins::RestrictionJob:#{Time.now.to_i / 1800}"
-      Resque::Plugins::RestrictionJob.redis_key(:per_7200).should == "Resque::Plugins::RestrictionJob:#{Time.now.to_i / 7200}"
+      expect(Resque::Plugins::RestrictionJob.redis_key(:per_1800)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / 1800}"
+      expect(Resque::Plugins::RestrictionJob.redis_key(:per_7200)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / 7200}"
     end
   end
-  
+
   context "settings" do
     it "get correct number to restriction jobs" do
-      OneDayRestrictionJob.settings.should == {:per_day => 100}
-      OneHourRestrictionJob.settings.should == {:per_hour => 10}
-      MultipleRestrictionJob.settings.should == {:per_hour => 10, :per_300 => 2}
-      MultiCallRestrictionJob.settings.should == {:per_hour => 10, :per_300 => 2}
+      expect(OneDayRestrictionJob.settings).to eq({:per_day => 100})
+      expect(OneHourRestrictionJob.settings).to eq({:per_hour => 10})
+      expect(MultipleRestrictionJob.settings).to eq({:per_hour => 10, :per_300 => 2})
+      expect(MultiCallRestrictionJob.settings).to eq({:per_hour => 10, :per_300 => 2})
     end
   end
-  
+
+  context 'restriction_queue_name' do
+    class MyJob < Resque::Plugins::RestrictionJob
+      queue_as 'awesome_queue_name'
+
+      def perform(args)
+      end
+    end
+
+    it 'concats restriction queue prefix with queue name' do
+      expect(MyJob.restriction_queue_name).to eq("#{Resque::Plugins::Restriction::RESTRICTION_QUEUE_PREFIX}_awesome_queue_name")
+    end
+  end
+
   context "resque" do
     include PerformJob
 
-    before(:each) do
+    before(:example) do
       Resque.redis.flushall
     end
-    
+
     it "should set execution number and decrement it when one job first executed" do
       result = perform_job(OneHourRestrictionJob, "any args")
-      result.should be_true
-      Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour)).should == "9"
+      expect(Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour))).to eq "9"
     end
 
     it "should use restriction_identifier to set exclusive execution counts" do
       result = perform_job(IdentifiedRestrictionJob, 1)
-      result.should be_true
       result = perform_job(IdentifiedRestrictionJob, 1)
-      result.should be_true
       result = perform_job(IdentifiedRestrictionJob, 2)
-      result.should be_true
-      Resque.redis.get(IdentifiedRestrictionJob.redis_key(:per_hour, 1)).should == "8"
-      Resque.redis.get(IdentifiedRestrictionJob.redis_key(:per_hour, 2)).should == "9"
+
+      expect(Resque.redis.get(IdentifiedRestrictionJob.redis_key(:per_hour, 1))).to eq "8"
+      expect(Resque.redis.get(IdentifiedRestrictionJob.redis_key(:per_hour, 2))).to eq "9"
     end
 
     it "should decrement execution number when one job executed" do
       Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), 6)
       result = perform_job(OneHourRestrictionJob, "any args")
-      result.should be_true
-      Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour)).should == "5"
+
+      expect(Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour))).to eq "5"
     end
 
     it "should increment execution number when concurrent job completes" do
       t = Thread.new do
-        result = perform_job(ConcurrentRestrictionJob, "any args")
-        result.should be_true
+        perform_job(ConcurrentRestrictionJob, "any args")
       end
       sleep 0.1
-      Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent)).should == "0"
+      expect(Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent))).to eq "0"
       t.join
-      Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent)).should == "1"
+      expect(Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent))).to eq "1"
     end
 
     it "should increment execution number when concurrent job fails" do
-      ConcurrentRestrictionJob.should_receive(:perform).and_raise("bad")
+      expect_any_instance_of(ConcurrentRestrictionJob).to receive(:perform).and_raise("bad")
       perform_job(ConcurrentRestrictionJob, "any args") rescue nil
-      Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent)).should == "1"
+      expect(Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent))).to eq "1"
     end
 
     it "should put the job into restriction queue when execution count < 0" do
       Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), 0)
       result = perform_job(OneHourRestrictionJob, "any args")
-      result.should_not be_true
-      Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour)).should == "0"
-      Resque.redis.lrange("queue:restriction_normal", 0, -1).should == [Resque.encode(:class => "OneHourRestrictionJob", :args => ["any args"])]
+      # expect(result).to_not be(true)
+      expect(Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour))).to eq "0"
+      expect(Resque.redis.lrange("queue:restriction_normal", 0, -1)).to eq [Resque.encode(:class => "OneHourRestrictionJob", :args => ["any args"])]
+    end
+
+    describe "expiration of period keys" do
+      class MyJob < Resque::Plugins::RestrictionJob
+        def perform(args)
+        end
+      end
+
+      shared_examples_for "expiration" do
+        before(:example) do
+          MyJob.restrict period => 10
+        end
+
+        context "when the key is not set" do
+          it "should mark period keys to expire" do
+            perform_job(MyJob, "any args")
+            expect(Resque.redis.ttl(MyJob.redis_key(period))).to eq MyJob.seconds(period)
+          end
+        end
+
+        context "when the key is set" do
+          before(:example) do
+            Resque.redis.set(MyJob.redis_key(period), 5)
+          end
+
+          it "should not mark period keys to expire" do
+            perform_job(MyJob, "any args")
+            expect(Resque.redis.ttl(MyJob.redis_key(period))).to eq -1
+          end
+        end
+      end
+
+      describe "per minute" do
+        def period
+          :per_minute
+        end
+
+        it_should_behave_like "expiration"
+      end
+
+      describe "per hour" do
+        def period
+          :per_hour
+        end
+
+        it_should_behave_like "expiration"
+      end
+
+      describe "per day" do
+        def period
+          :per_day
+        end
+
+        it_should_behave_like "expiration"
+      end
+
+      describe "per week" do
+        def period
+          :per_week
+        end
+
+        it_should_behave_like "expiration"
+      end
+
+      describe "per month" do
+        def period
+          :per_month
+        end
+
+        it_should_behave_like "expiration"
+      end
+
+      describe "per year" do
+        def period
+          :per_year
+        end
+
+        it_should_behave_like "expiration"
+      end
+
+      describe "per custom period" do
+        def period
+          :per_359
+        end
+
+        it_should_behave_like "expiration"
+      end
     end
 
     context "multiple restrict" do
       it "should restrict per_minute" do
         result = perform_job(MultipleRestrictionJob, "any args")
-        Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour)).should == "9"
-        Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300)).should == "1"
+        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour))).to eq "9"
+        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300))).to eq "1"
         result = perform_job(MultipleRestrictionJob, "any args")
         result = perform_job(MultipleRestrictionJob, "any args")
-        Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour)).should == "8"
-        Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300)).should == "0"
+        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour))).to eq "8"
+        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300))).to eq "0"
       end
 
       it "should restrict per_hour" do
         Resque.redis.set(MultipleRestrictionJob.redis_key(:per_hour), 1)
         Resque.redis.set(MultipleRestrictionJob.redis_key(:per_300), 2)
         result = perform_job(MultipleRestrictionJob, "any args")
-        Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour)).should == "0"
-        Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300)).should == "1"
+        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour))).to eq "0"
+        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300))).to eq "1"
         result = perform_job(MultipleRestrictionJob, "any args")
-        Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour)).should == "0"
-        Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300)).should == "1"
+        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour))).to eq "0"
+        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300))).to eq "1"
       end
     end
 
     context "repush" do
       it "should push restricted jobs onto restriction queue" do
         Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), -1)
-        Resque.should_receive(:push).once.with('restriction_normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
-        OneHourRestrictionJob.repush('any args').should be_true
+        expect(Resque).to receive(:push).once.with('restriction_normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
+        expect(OneHourRestrictionJob.repush('any args')).to be(true)
       end
 
       it "should not push unrestricted jobs onto restriction queue" do
         Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), 1)
-        Resque.should_not_receive(:push)
-        OneHourRestrictionJob.repush('any args').should be_false
+        expect(Resque).not_to receive(:push)
+        expect(OneHourRestrictionJob.repush('any args')).to be(false)
       end
 
     end

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-require 'spec/autorun'
 require 'mocha'
 
 dir = File.dirname(__FILE__)
@@ -38,53 +37,52 @@ puts "Starting redis for testing at localhost:9736..."
 `redis-server #{dir}/redis-test.conf`
 Resque.redis = 'localhost:9736'
 
-##
+#
 # Helper to perform job classes
 #
 module PerformJob
   def perform_job(klass, *args)
-    resque_job = Resque::Job.new(:testqueue, 'class' => klass, 'args' => args)
-    resque_job.perform
+    klass.perform_now(*args)
   end
 end
 
 class OneDayRestrictionJob < Resque::Plugins::RestrictionJob
   restrict :per_day => 100
 
-  @queue = 'normal'
-  
-  def self.perform(args)
+  queue_as 'normal'
+
+  def perform(args)
   end
 end
 
 class OneHourRestrictionJob < Resque::Plugins::RestrictionJob
   restrict :per_hour => 10
 
-  @queue = 'normal'
+  queue_as 'normal'
 
-  def self.perform(args)
+  def perform(args)
   end
 end
 
 class IdentifiedRestrictionJob < Resque::Plugins::RestrictionJob
   restrict :per_hour => 10
 
-  @queue = 'normal'
+  queue_as 'normal'
 
   def self.restriction_identifier(*args)
     [self.to_s, args.first].join(":")
   end
 
-  def self.perform(*args)
+  def perform(args)
   end
 end
 
 class ConcurrentRestrictionJob < Resque::Plugins::RestrictionJob
   restrict :concurrent => 1
 
-  @queue = 'normal'
+  queue_as 'normal'
 
-  def self.perform(*args)
+  def perform(args)
     sleep 0.2
   end
 end
@@ -92,9 +90,9 @@ end
 class MultipleRestrictionJob < Resque::Plugins::RestrictionJob
   restrict :per_hour => 10, :per_300 => 2
 
-  @queue = 'normal'
+  queue_as 'normal'
 
-  def self.perform(args)
+  def perform(args)
   end
 end
 
@@ -102,8 +100,8 @@ class MultiCallRestrictionJob < Resque::Plugins::RestrictionJob
   restrict :per_hour => 10
   restrict :per_300 => 2
 
-  @queue = 'normal'
+  queue_as 'normal'
 
-  def self.perform(args)
+  def perform(args)
   end
-end
+end

metadata

@@ -1,51 +1,56 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: resque-restriction
-version: !ruby/object:Gem::Version 
-  hash: 19
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  - 0
-  version: 0.3.0
+version: !ruby/object:Gem::Version
+  version: 0.4.0
 platform: ruby
-authors: 
+authors:
 - Richard Huang
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-11-04 00:00:00 +08:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: resque
+date: 2015-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: resque-restriction
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 1
-        - 7
-        - 0
+      - !ruby/object:Gem::Version
         version: 1.7.0
   type: :runtime
-  version_requirements: *id001
-description: resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time, the exceeded jobs will be executed at the next period.
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+description: resque-restriction is an extension to resque queue system that restricts
+  the execution number of certain jobs in a period time, the exceeded jobs will be
+  executed at the next period.
 email: flyerhzm@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE
 - README.markdown
-files: 
-- .gitignore
-- .rvmrc.example
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
 - LICENSE
 - README.markdown
 - Rakefile
@@ -59,43 +64,29 @@ files:
 - spec/redis-test.conf
 - spec/resque-restriction/job_spec.rb
 - spec/resque-restriction/restriction_job_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/flyerhzm/resque-restriction
 licenses: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.4.8
 signing_key: 
-specification_version: 3
-summary: resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time.
-test_files: 
-- spec/resque-restriction/job_spec.rb
-- spec/resque-restriction/restriction_job_spec.rb
-- spec/spec_helper.rb
+specification_version: 4
+summary: resque-restriction is an extension to resque queue system that restricts
+  the execution number of certain jobs in a period time.
+test_files: []

data/.gitignore

@@ -1,5 +0,0 @@
-spec/dump.rdb
-pkg/**
-.idea
-.rvmrc
-

data/.rvmrc.example

@@ -1,2 +0,0 @@
-rvm_gemset_create_on_use_flag=1
-rvm gemset use resque-restriction

data/spec/spec.opts

@@ -1,8 +0,0 @@
---colour
---format
-specdoc
---reverse
---timeout
-20
---loadby
-mtime