resque-status 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a4382134fbba02bad15ec7adb476b1f1d14ec29
-  data.tar.gz: 239fa4abd391dcc1d7b48ff8500d700feb894d82
+  metadata.gz: ae0e88243130c82e68fd3c7067afe397241581f9
+  data.tar.gz: db0b3eb29ed79f8508a11bef17561f525e54f37c
 SHA512:
-  metadata.gz: c3f7917eac96cd4d2db4612ca93b5c000165b372a69457e501b0e1a0af9f82cdbdcd82a390cca7c3331cd3f4228717cd1d18575729fcb9deaa6c5a2cd6462563
-  data.tar.gz: 814e1a1eee96821f0c663545990071da35684c32ce16476655d859943ef2a72f591ece87d0097d0d480e4fd5fcaa4507ef86171506e8f82bb0a3ef831d8d1da1
+  metadata.gz: c38a1f2b8365011691d842b240b57e1de4a5828e199f8c2e3333ff17b20ab1991b75b25d92930ba8d2c204520ab2793b11d1c092c81e2ed6ec13e8aaba9c6c41
+  data.tar.gz: e5083dd52ffd3cece9dc3817ae2c0d3bc69656cbd3df19d900dbdce6096282b15e4d8eceb0187542b747c9eed864a57d6c4b86d9afa64fb7800fbefeb622d721

data/Gemfile

@@ -4,7 +4,7 @@ gem 'resque', '~>1.19'
 
 group :test do
   gem 'mocha', '~>0.9'
-  gem 'shoulda', '~>2.10.2'
+  gem 'minitest', '~> 5.5'
 end
 
 group :development do

data/Gemfile.lock

@@ -27,6 +27,7 @@ GEM
     json (1.8.1)
     metaclass (0.0.2)
     mini_portile (0.5.2)
+    minitest (5.5.1)
     mocha (0.14.0)
       metaclass (~> 0.0.1)
     multi_json (1.3.6)
@@ -50,7 +51,6 @@ GEM
       redis-namespace (~> 1.0)
       sinatra (>= 0.9.2)
       vegas (~> 0.1.2)
-    shoulda (2.10.3)
     sinatra (1.3.3)
       rack (~> 1.3, >= 1.3.6)
       rack-protection (~> 1.2)
@@ -64,6 +64,6 @@ PLATFORMS
 
 DEPENDENCIES
   jeweler
+  minitest (~> 5.5)
   mocha (~> 0.9)
   resque (~> 1.19)
-  shoulda (~> 2.10.2)

data/README.rdoc

@@ -4,25 +4,20 @@ resque-status is an extension to the resque queue system that provides simple tr
 
 == About
 
-resque-status provides a set of simple classes that extend resque's default 
+resque-status provides a set of simple classes that extend resque's default
 functionality (with 0% monkey patching) to give apps a way to track specific
 job instances and their status. It achieves this by giving job instances UUID's
 and allowing the job instances to report their status from within their iterations.
 
 == Installation
 
-resque-status *requires Redis >= 1.1* (though I recommend getting the latest stable version). 
-You can download Redis here: http://code.google.com/p/redis/ or install it 
+resque-status *requires Redis >= 1.1* (though I recommend getting the latest stable version).
+You can download Redis here: http://code.google.com/p/redis/ or install it
 using homebrew (brew install redis).
 
 Install the resque-status gem (which will pull in the dependencies).
 
   gem install resque-status
-  
-To use with Rails 2.x, you can install as a plugin or add the gem to you're config:
-  
-  # environment.rb
-  config.gem 'resque-status'
 
 With newer Rails add this to your Gemfile:
 
@@ -30,64 +25,52 @@ With newer Rails add this to your Gemfile:
   gem 'resque-status'
 
 Then in an initializer:
-  
+
   # config/initializers/resque.rb
   Resque.redis = "your/redis/socket" # default localhost:6379
   Resque::Plugins::Status::Hash.expire_in = (24 * 60 * 60) # 24hrs in seconds
 
-== NOTES ABOUT UPGRADING TO >= v0.3 
-
-Even though this was one of the first resque plugins, later versions of resque added stricter plugin conventions 
-that resque-status did not completely conform to (See: https://github.com/defunkt/resque/blob/master/docs/PLUGINS.md)
-
-Thanks to some work from @EugZol and @bukowskis v0.3 moved around some code to conform:
-
-`Resque::Status` is now `Resque::Plugins::Status` and is now an `include`able module.
-`Resque::Status.get/etc` have been moved to `Resque::Plugins::Status::Hash`
-  
 == Usage
 
-The most direct way to use resque-status is to create your jobs using the 
+The most direct way to use resque-status is to create your jobs using the
 Resque::Plugins::Status module. An example job would look something like:
 
   class SleepJob
     include Resque::Plugins::Status
-  
+
     def perform
       total = (options['length'] || 1000).to_i
-      num = 0
-      while num < total
+      total.times do |i|
+        num = i+1
         at(num, total, "At #{num} of #{total}")
         sleep(1)
-        num += 1
       end
     end
-  
   end
 
-One major difference is that instead of implementing <tt>perform</tt> as a 
+One major difference is that instead of implementing <tt>perform</tt> as a
 class method, we do our job implementation within instances of the job class.
 
 In order to queue a SleepJob up, we also won't use <tt>Resque.enqueue</tt>, instead
-we'll use the <tt>create</tt> class method which will wrap <tt>enqueue</tt> and 
+we'll use the <tt>create</tt> class method which will wrap <tt>enqueue</tt> and
 creating a unique id (UUID) for us to track the job with.
 
-  job_id = SleepJob.create(:length => 100)
-  
+  job_id = SleepJob.create(length: 100)
+
 This will create a UUID enqueue the job and pass the :length option on the SleepJob
 instance as options['length'] (as you can see above).
 
 Now that we have a UUID its really easy to get the status:
 
   status = Resque::Plugins::Status::Hash.get(job_id)
-  
+
 This returns a Resque::Plugins::Status::Hash object, which is a Hash (with benefits).
 
   status.pct_complete #=> 0
   status.status #=> 'queued'
   status.queued? #=> true
   status.working? #=> false
-  status.time #=> Time object        
+  status.time #=> Time object
   status.message #=> "Created at ..."
 
 Once the worker reserves the job, the instance of SleepJob updates the status at
@@ -96,8 +79,8 @@ each iteration using <tt>at()</tt>
   status = Resque::Plugins::Status::Hash.get(job_id)
   status.working? #=> true
   status.num #=> 5
-  status.total => 100
-  status.pct_complete => 5
+  status.total #=> 100
+  status.pct_complete #=> 5
 
 If an error occurs within the job instance, the status is set to 'failed' and then
 the error is re-raised so that Resque can capture it.
@@ -115,7 +98,7 @@ download by the user.
 
 A Status is actually just a hash, so inside a job you can do:
 
-    status['filename'] = '/myfilename'
+    set_status(filename: "myfilename")
 
 Also, all the status setting methods take any number of hash arguments. So you could do:
 
@@ -129,7 +112,7 @@ by UUID.
 
   Resque::Plugins::Status::Hash.kill(job_id)
 
-The next time the job at job_id calls <tt>at</tt> or <tt>tick</tt>, it will raise a <tt>Killed</tt> 
+The next time the job at job_id calls <tt>at</tt> or <tt>tick</tt>, it will raise a <tt>Killed</tt>
 error and set the status to killed.
 
 === Percent Complete and setting the message
@@ -142,53 +125,53 @@ is raised if the job is killed.
 
 === Expiration
 
-Since Redis is RAM based, we probably don't want to keep these statuses around forever 
+Since Redis is RAM based, we probably don't want to keep these statuses around forever
 (at least until @antirez releases the VM feature). By setting expire_in, all statuses
 and their related keys will expire in expire_in seconds from the last time theyre updated:
 
   Resque::Plugins::Status::Hash.expire_in = (60 * 60) # 1 hour
 === Testing
 
-Recent versions of Resque introduced `Resque.inline` which changes the behavior to 
+Recent versions of Resque introduced `Resque.inline` which changes the behavior to
 instead of enqueueing and performing jobs to just executing them inline. In Resque
 itself this removes the dependency on a Redis, however, `Resque::Status` uses Redis
 to store information about jobs, so though `inline` "works", you will still need
-to use or mock a redis connection. You should be able to use a library like 
+to use or mock a redis connection. You should be able to use a library like
 https://github.com/causes/mock_redis alongside `inline` if you really want to
 avoid Redis connections in your test.
 
 === resque-web
 
 Though the main purpose of these trackable jobs is to allow you to surface the status
-of user created jobs through you're apps' own UI, I've added a simple example UI
+of user created jobs through your apps' own UI, I've added a simple example UI
 as a plugin to resque-web.
 
 To use, you need to setup a resque-web config file:
 
-  # ~/resque_conf.rb  
+  # ~/resque_conf.rb
   require 'resque/status_server'
-  
+
 Then start resque-web with your config:
 
   resque-web ~/resque_conf.rb
-  
+
 This should launch resque-web in your browser and you should see a 'Statuses' tab.
 
 http://img.skitch.com/20100119-k166xyijcjpkk6xtwnw3854a8g.jpg
-      
+
 == More
 
 Source: http://github.com/quirkey/resque-status
 API Docs: http://rdoc.info/projects/quirkey/resque-status
 Examples: http://github.com/quirkey/resque-status/tree/master/examples
 Resque: http://github.com/defunkt/resque
-            
+
 == Thanks
 
-Resque is awesome, @defunkt needs a shout-out. 
-  
+Resque is awesome, @defunkt needs a shout-out.
+
 == Note on Patches/Pull Requests
- 
+
 * Fork the project.
 * Make your feature addition or bug fix.
 * Add tests for it. This is important so I don't break it in a

data/lib/resque/plugins/status.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
 
-    # Resque::Plugins::Status is a module you're jobs will include.
+    # Resque::Plugins::Status is a module your jobs will include.
     # It provides helper methods for updating the status/etc from within an
     # instance as well as class methods for creating and queuing the jobs.
     #
@@ -28,7 +28,7 @@ module Resque
     # This job would iterate num times updating the status as it goes. At the end
     # we update the status telling anyone listening to this job that its complete.
     module Status
-      VERSION = '0.4.3'
+      VERSION = '0.5.0'
 
       STATUS_QUEUED = 'queued'
       STATUS_WORKING = 'working'

data/lib/resque/plugins/status/hash.rb

@@ -56,17 +56,23 @@ module Resque
 
         def self.clear_completed(range_start = nil, range_end = nil)
           status_ids(range_start, range_end).select do |id|
-            get(id).completed?
-          end.each do |id|
-            remove(id)
+            if get(id).completed?
+              remove(id)
+              true
+            else
+              false
+            end
           end
         end
 
         def self.clear_failed(range_start = nil, range_end = nil)
           status_ids(range_start, range_end).select do |id|
-            get(id).failed?
-          end.each do |id|
-            remove(id)
+            if get(id).failed?
+              remove(id)
+              true
+            else
+              false
+            end
           end
         end
 

data/lib/resque/server/views/status.erb

@@ -1,18 +1,20 @@
 <%= status_view :status_styles, :layout => false %>
 
-<h1 class='wi'>Statuses: <%= @status.uuid %>/<%= @status.name %></h1>
+<h1 class='wi'>Status <%= @status.uuid %></h1>
 <p class='intro'>Viewing a specific job created with Resque::Plugins::Status. <a href="<%= u(:statuses) %>">Return to the list of statuses</a></p>
 
 <div class="status-holder" rel="<%= @status.status %>" id="status_<%= @status.uuid %>">
+  <h2>Overview</h2>
   <div class="status-progress">
     <div class="status-progress-bar status-<%= @status.status %>" style="width: <%= @status.pct_complete %>%;"></div>
     <p><%= @status.pct_complete %>%</p>
   </div>
   <div class="status-message"><%= @status.message %></div>
   <div class="status-time"><%= @status.time? ? @status.time : 'Not started' %></div>
+
   <h2>Details</h2>
   <div class="status-details">
-    <table>
+    <table class="vertically-top">
       <thead>
         <tr>
           <th>Key</th>
@@ -81,7 +83,7 @@
         time.setTime(value * 1000);
         return time.toUTCString();
       } else {
-        return JSON.stringify(value);
+        return JSON.stringify(value, null, " ");
       }
     }
 

data/lib/resque/server/views/status_styles.erb

@@ -26,6 +26,12 @@
     z-index: 10;
     color: #333;
   }
+  table.vertically-top td {
+    vertical-align: text-top;
+  }
+  table.vertically-top tr {
+    border: 1px solid #ccc;
+  }
 
   .status-holder {
     background: #F7F7F7;

data/lib/resque/server/views/statuses.erb

@@ -1,19 +1,21 @@
 <%= status_view :status_styles, :layout => false %>
 
 <h1 class='wi'>Statuses</h1>
+
 <%unless @statuses.empty?%>
-<form method="POST" action="<%= u(:statuses) %>/clear" class='clear-failed'>
-  <input type='submit' name='' value='Clear Statuses' onclick='return confirm("Are you absolutely sure? This cannot be undone.");' />
-</form>
-<form method="POST" action="<%= u(:statuses) %>/clear/completed" class='clear-failed'>
-  <input type='submit' name='' value='Clear Completed Statuses' onclick='return confirm("Are you absolutely sure? This cannot be undone.");' />
-</form>
-<form method="POST" action="<%= u(:statuses) %>/clear/failed" class='clear-failed'>
-  <input type='submit' name='' value='Clear Failed Statuses' onclick='return confirm("Are you absolutely sure? This cannot be undone.");' />
-</form>
+  <form method="POST" action="<%= u(:statuses) %>/clear" class='clear-failed'>
+    <input type='submit' name='' value='Clear Statuses' onclick='return confirm("Are you absolutely sure? This cannot be undone.");' />
+  </form>
+  <form method="POST" action="<%= u(:statuses) %>/clear/completed" class='clear-failed'>
+    <input type='submit' name='' value='Clear Completed Statuses' onclick='return confirm("Are you absolutely sure? This cannot be undone.");' />
+  </form>
+  <form method="POST" action="<%= u(:statuses) %>/clear/failed" class='clear-failed'>
+    <input type='submit' name='' value='Clear Failed Statuses' onclick='return confirm("Are you absolutely sure? This cannot be undone.");' />
+  </form>
 <%end%>
+
 <p class='intro'>These are recent jobs created with the Resque::Plugins::Status class</p>
-<table>
+<table class="vertically-top">
   <tr>
     <th>ID</th>
     <th>Name</th>
@@ -46,7 +48,7 @@
 </table>
 
 <% unless @statuses.empty? %>
-  <%= partial :next_more, :start => @start, :size => @size %>
+  <%= partial :next_more, :start => @start, :size => @size, :per_page => per_page %>
 <% end %>
 
 <%= status_poll(@start) %>

data/lib/resque/status_server.rb

@@ -5,14 +5,15 @@ module Resque
   module StatusServer
 
     VIEW_PATH = File.join(File.dirname(__FILE__), 'server', 'views')
+    PER_PAGE = 50
 
     def self.registered(app)
 
       app.get '/statuses' do
         @start = params[:start].to_i
-        @end = @start + (params[:per_page] || 50)
+        @end = @start + (params[:per_page] || per_page) - 1
         @statuses = Resque::Plugins::Status::Hash.statuses(@start, @end)
-        @size = @statuses.size
+        @size = Resque::Plugins::Status::Hash.count
         status_view(:statuses)
       end
 
@@ -52,14 +53,17 @@ module Resque
         @polling = true
 
         @start = params[:start].to_i
-        @end = @start + (params[:per_page] || 50)
+        @end = @start + (params[:per_page] || per_page) - 1
         @statuses = Resque::Plugins::Status::Hash.statuses(@start, @end)
-        @size = @statuses.size
-
+        @size = Resque::Plugins::Status::Hash.count
         status_view(:statuses, {:layout => false})
       end
 
       app.helpers do
+        def per_page
+          PER_PAGE
+        end
+
         def status_view(filename, options = {}, locals = {})
           erb(File.read(File.join(::Resque::StatusServer::VIEW_PATH, "#{filename}.erb")), options, locals)
         end

data/resque-status.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: resque-status 0.4.3 ruby lib
+# stub: resque-status 0.5.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "resque-status"
-  s.version = "0.4.3"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Aaron Quint"]
-  s.date = "2014-05-12"
+  s.date = "2015-03-18"
   s.description = "resque-status is an extension to the resque queue system that provides simple trackable jobs. It provides a Resque::Plugins::Status::Hash class which can set/get the statuses of jobs and a Resque::Plugins::Status class that when included provides easily trackable/killable jobs."
   s.email = "aaron@quirkey.com"
   s.extra_rdoc_files = [
@@ -44,7 +44,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/quirkey/resque-status"
   s.rubyforge_project = "quirkey"
-  s.rubygems_version = "2.2.1"
+  s.rubygems_version = "2.2.2"
   s.summary = "resque-status is an extension to the resque queue system that provides simple trackable jobs."
 
   if s.respond_to? :specification_version then

data/test/redis-test.conf

@@ -48,10 +48,10 @@ dir ./test/
 # warning (only very important / critical messages are logged)
 loglevel debug
 
-# Specify the log file name. Also 'stdout' can be used to force
-# the demon to log on the standard output. Note that if you use standard
+# Specify the log file name. Also the empty string can be used to force
+# Redis to log on the standard output. Note that if you use standard
 # output for logging but daemonize, logs will be sent to /dev/null
-logfile stdout
+logfile ""
 
 # Set the number of databases. The default database is DB 0, you can select
 # a different one on a per-connection basis using SELECT <dbid> where
@@ -109,11 +109,6 @@ databases 16
 
 ############################### ADVANCED CONFIG ###############################
 
-# 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
-
 # 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
 # pool so it uses more CPU and can be a bit slower. Usually it's a good

data/test/test_helper.rb

@@ -1,15 +1,8 @@
-dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift dir + '/../lib'
-$TESTING = true
-require 'test/unit'
-require 'rubygems'
-require 'shoulda'
-require 'mocha/setup'
-
+require 'bundler/setup'
 require 'resque-status'
 
-class Test::Unit::TestCase
-end
+require 'minitest/autorun'
+require 'mocha/setup'
 
 #
 # make sure we can run redis
@@ -26,23 +19,20 @@ end
 # kill it when they end
 #
 
-at_exit do
-  next if $!
 
-  if defined?(MiniTest)
-    exit_code = MiniTest::Unit.new.run(ARGV)
-  else
-    exit_code = Test::Unit::AutoRunner.run
+class << Minitest
+  def exit(*args)
+    pid = `ps -e -o pid,command | grep [r]edis.*9736`.split(" ")[0]
+    puts "Killing test redis server..."
+    Process.kill("KILL", pid.to_i)
+    super
   end
-
-  pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
-  puts "Killing test redis server..."
-  Process.kill("KILL", pid.to_i)
-  exit exit_code
 end
 
+dir = File.expand_path("../", __FILE__)
 puts "Starting redis for testing at localhost:9736..."
-`rm -f #{dir}/dump.rdb && redis-server #{dir}/redis-test.conf`
+result = `rm -f #{dir}/dump.rdb && redis-server #{dir}/redis-test.conf`
+raise "Redis failed to start: #{result}" unless $?.success?
 Resque.redis = 'localhost:9736/1'
 
 #### Fixtures

data/test/test_resque_plugins_status.rb

@@ -1,220 +1,224 @@
 require 'test_helper'
 
-class TestResquePluginsStatus < Test::Unit::TestCase
+class TestResquePluginsStatus < Minitest::Test
 
-  context "Resque::Plugins::Status" do
-    setup do
+  describe "Resque::Plugins::Status" do
+    before do
       Resque.redis.flushall
     end
 
-    context ".create" do
-      context "not inline" do
-        setup do
+    describe ".create" do
+      describe "not inline" do
+        before do
           @uuid = WorkingJob.create('num' => 100)
         end
 
-        should "add the job to the queue" do
+        it "add the job to the queue" do
           assert_equal 1, Resque.size(:statused)
         end
 
-        should "set the queued object to the current class" do
+        it "set the queued object to the current class" do
           job = Resque.pop(:statused)
           assert_equal @uuid, job['args'].first
           assert_equal "WorkingJob", job['class']
         end
 
-        should "add the uuid to the statuses" do
-          assert_contains Resque::Plugins::Status::Hash.status_ids, @uuid
+        it "add the uuid to the statuses" do
+          assert_includes Resque::Plugins::Status::Hash.status_ids, @uuid
         end
 
-        should "return a UUID" do
+        it "return a UUID" do
           assert_match(/^\w{32}$/, @uuid)
         end
       end
 
-      context "inline" do
-        setup do
+      describe "inline" do
+        before do
           Resque.stubs(:inline?).returns(true)
         end
 
-        should "not queue a job" do
+        it "not queue a job" do
           @uuid = WorkingJob.create('num' => 100)
           assert_equal 0, Resque.size(:statused)
         end
 
-        should "call perform" do
+        it "call perform" do
           WorkingJob.any_instance.expects(:perform).once
           @uuid = WorkingJob.create('num' => 100)
         end
       end
     end
 
-    context ".create with a failing before_enqueue hook" do
-      setup do
+    describe ".create with a failing before_enqueue hook" do
+      before do
         @size = Resque.size(:statused)
         @status_ids_size = Resque::Plugins::Status::Hash.status_ids.length
         @res = NeverQueuedJob.create(:num => 100)
       end
 
-      should "return nil" do
+      it "return nil" do
         assert_equal nil, @res
       end
 
-      should "not create a status" do
+      it "not create a status" do
         assert_equal @size, Resque.size(:statused)
       end
 
-      should "not add the uuid to the statuses" do
+      it "not add the uuid to the statuses" do
         assert_equal @status_ids_size, Resque::Plugins::Status::Hash.status_ids.length
       end
     end
 
-    context ".scheduled" do
-      setup do
+    describe ".scheduled" do
+      before do
         @job_args = {'num' => 100}
         @uuid = WorkingJob.scheduled(:queue_name, WorkingJob, @job_args)
       end
 
-      should "create the job with the provided arguments" do
+      it "create the job with the provided arguments" do
         job = Resque.pop(:queue_name)
         assert_equal @job_args, job['args'].last
       end
     end
 
-    context ".enqueue" do
-      should "delegate to enqueue_to, filling in the queue from the class" do
+    describe ".enqueue" do
+      it "delegate to enqueue_to, filling in the queue from the class" do
         @uuid = BasicJob.enqueue(WorkingJob, :num => 100)
         @payload = Resque.pop(:statused)
         assert_equal "WorkingJob", @payload['class']
       end
     end
 
-    context ".enqueue_to" do
-      setup do
+    describe ".enqueue_to" do
+      before do
         @uuid = BasicJob.enqueue_to(:new_queue, WorkingJob, :num => 100)
         @payload = Resque.pop(:new_queue)
       end
 
-      should "add the job with the specific class to the queue" do
+      it "add the job with the specific class to the queue" do
         assert_equal "WorkingJob", @payload['class']
       end
 
-      should "add the arguments to the options hash" do
+      it "add the arguments to the options hash" do
         assert_equal @uuid, @payload['args'].first
       end
 
-      should "add the uuid to the statuses" do
-        assert_contains Resque::Plugins::Status::Hash.status_ids, @uuid
+      it "add the uuid to the statuses" do
+        assert_includes Resque::Plugins::Status::Hash.status_ids, @uuid
       end
 
-      should "return UUID" do
+      it "return UUID" do
         assert_match(/^\w{32}$/, @uuid)
       end
 
     end
 
-    context ".dequeue" do
-      setup do
+    describe ".dequeue" do
+      before do
         @uuid1 = BasicJob.enqueue(WorkingJob, :num => 100)
         @uuid2 = BasicJob.enqueue(WorkingJob, :num => 100)
       end
 
-      should "dequeue the job with the uuid from the correct queue" do
+      it "dequeue the job with the uuid from the correct queue" do
         size = Resque.size(:statused)
         BasicJob.dequeue(WorkingJob, @uuid2)
         assert_equal size-1, Resque.size(:statused)
       end
-      should "not dequeue any jobs with different uuids for same class name" do
+      it "not dequeue any jobs with different uuids for same class name" do
         BasicJob.dequeue(WorkingJob, @uuid2)
         assert_equal @uuid1, Resque.pop(:statused)['args'].first
       end
     end
 
-    context ".perform" do
-      setup do
+    describe ".perform" do
+      let(:expectation) { }
+
+      before do
+        expectation
         @uuid      = WorkingJob.create(:num => 100)
         @payload   = Resque.pop(:statused)
         @performed = WorkingJob.perform(*@payload['args'])
       end
 
-      should "load load a new instance of the klass" do
+      it "load load a new instance of the klass" do
         assert @performed.is_a?(WorkingJob)
       end
 
-      should "set the uuid" do
+      it "set the uuid" do
         assert_equal @uuid, @performed.uuid
       end
 
-      should "set the status" do
+      it "set the status" do
         assert @performed.status.is_a?(Resque::Plugins::Status::Hash)
         assert_equal 'WorkingJob({"num"=>100})', @performed.status.name
       end
 
-      before_should "call perform on the inherited class" do
-        WorkingJob.any_instance.expects(:perform).once
+      describe "before" do
+        let(:expectation) { WorkingJob.any_instance.expects(:perform).once }
+        it("call perform on the inherited class") {}
       end
     end
 
-    context "manually failing a job" do
-      setup do
+    describe "manually failing a job" do
+      before do
         @uuid      = FailureJob.create(:num => 100)
         @payload   = Resque.pop(:statused)
         @performed = FailureJob.perform(*@payload['args'])
       end
 
-      should "load load a new instance of the klass" do
+      it "load load a new instance of the klass" do
         assert @performed.is_a?(FailureJob)
       end
 
-      should "set the uuid" do
+      it "set the uuid" do
         assert_equal @uuid, @performed.uuid
       end
 
-      should "set the status" do
+      it "set the status" do
         assert @performed.status.is_a?(Resque::Plugins::Status::Hash)
         assert_equal 'FailureJob({"num"=>100})', @performed.status.name
       end
 
-      should "be failed" do
+      it "be failed" do
         assert_match(/failure/, @performed.status.message)
         assert @performed.status.failed?
       end
 
     end
 
-    context "killing a job" do
-      setup do
+    describe "killing a job" do
+      before do
         @uuid      = KillableJob.create(:num => 100)
         @payload   = Resque.pop(:statused)
         Resque::Plugins::Status::Hash.kill(@uuid)
-        assert_contains Resque::Plugins::Status::Hash.kill_ids, @uuid
+        assert_includes Resque::Plugins::Status::Hash.kill_ids, @uuid
         @performed = KillableJob.perform(*@payload['args'])
         @status = Resque::Plugins::Status::Hash.get(@uuid)
       end
 
-      should "set the status to killed" do
+      it "set the status to killed" do
         assert @status.killed?
         assert !@status.completed?
       end
 
-      should "only perform iterations up to kill" do
+      it "only perform iterations up to kill" do
         assert_equal 1, Resque.redis.get("#{@uuid}:iterations").to_i
       end
 
-      should "not persist the kill key" do
-        assert_does_not_contain Resque::Plugins::Status::Hash.kill_ids, @uuid
+      it "not persist the kill key" do
+        refute_includes Resque::Plugins::Status::Hash.kill_ids, @uuid
       end
     end
 
-    context "killing all jobs" do
-      setup do
+    describe "killing all jobs" do
+      before do
         @uuid1    = KillableJob.create(:num => 100)
         @uuid2    = KillableJob.create(:num => 100)
 
         Resque::Plugins::Status::Hash.killall
 
-        assert_contains Resque::Plugins::Status::Hash.kill_ids, @uuid1
-        assert_contains Resque::Plugins::Status::Hash.kill_ids, @uuid2
+        assert_includes Resque::Plugins::Status::Hash.kill_ids, @uuid1
+        assert_includes Resque::Plugins::Status::Hash.kill_ids, @uuid2
 
         @payload1   = Resque.pop(:statused)
         @payload2   = Resque.pop(:statused)
@@ -225,34 +229,34 @@ class TestResquePluginsStatus < Test::Unit::TestCase
         @status1, @status2 = Resque::Plugins::Status::Hash.mget([@uuid1, @uuid2])
       end
 
-      should "set the status to killed" do
+      it "set the status to killed" do
         assert @status1.killed?
         assert !@status1.completed?
         assert @status2.killed?
         assert !@status2.completed?
       end
 
-      should "only perform iterations up to kill" do
+      it "only perform iterations up to kill" do
         assert_equal 1, Resque.redis.get("#{@uuid1}:iterations").to_i
         assert_equal 1, Resque.redis.get("#{@uuid2}:iterations").to_i
       end
 
-      should "not persist the kill key" do
-        assert_does_not_contain Resque::Plugins::Status::Hash.kill_ids, @uuid1
-        assert_does_not_contain Resque::Plugins::Status::Hash.kill_ids, @uuid2
+      it "not persist the kill key" do
+        refute_includes Resque::Plugins::Status::Hash.kill_ids, @uuid1
+        refute_includes Resque::Plugins::Status::Hash.kill_ids, @uuid2
       end
 
     end
 
-    context "invoking killall jobs to kill a range" do
-      setup do
+    describe "invoking killall jobs to kill a range" do
+      before do
         @uuid1    = KillableJob.create(:num => 100)
         @uuid2    = KillableJob.create(:num => 100)
 
-        Resque::Plugins::Status::Hash.killall(0,0) # only @uuid2 should be killed
+        Resque::Plugins::Status::Hash.killall(0,0) # only @uuid2 it be killed
 
-        assert_does_not_contain Resque::Plugins::Status::Hash.kill_ids, @uuid1
-        assert_contains Resque::Plugins::Status::Hash.kill_ids, @uuid2
+        refute_includes Resque::Plugins::Status::Hash.kill_ids, @uuid1
+        assert_includes Resque::Plugins::Status::Hash.kill_ids, @uuid2
 
         @payload1   = Resque.pop(:statused)
         @payload2   = Resque.pop(:statused)
@@ -263,86 +267,86 @@ class TestResquePluginsStatus < Test::Unit::TestCase
         @status1, @status2 = Resque::Plugins::Status::Hash.mget([@uuid1, @uuid2])
       end
 
-      should "set the status to killed" do
+      it "set the status to killed" do
         assert !@status1.killed?
         assert @status1.completed?
         assert @status2.killed?
         assert !@status2.completed?
       end
 
-      should "only perform iterations up to kill" do
+      it "only perform iterations up to kill" do
         assert_equal 100, Resque.redis.get("#{@uuid1}:iterations").to_i
         assert_equal 1, Resque.redis.get("#{@uuid2}:iterations").to_i
       end
 
-      should "not persist the kill key" do
-        assert_does_not_contain Resque::Plugins::Status::Hash.kill_ids, @uuid1
-        assert_does_not_contain Resque::Plugins::Status::Hash.kill_ids, @uuid2
+      it "not persist the kill key" do
+        refute_includes Resque::Plugins::Status::Hash.kill_ids, @uuid1
+        refute_includes Resque::Plugins::Status::Hash.kill_ids, @uuid2
       end
 
     end
 
-    context "with an invoked job" do
-      setup do
+    describe "with an invoked job" do
+      before do
         @job = WorkingJob.new('123', {'num' => 100})
       end
 
-      context "#at" do
-        setup do
+      describe "#at" do
+        before do
           @job.at(50, 100, "At 50%")
         end
 
-        should "calculate percent" do
+        it "calculate percent" do
           assert_equal 50, @job.status.pct_complete
         end
 
-        should "set status" do
+        it "set status" do
           assert @job.status.working?
         end
 
-        should "save message" do
+        it "save message" do
           assert_equal "At 50%", @job.status.message
         end
       end
 
-      context "#failed" do
-        setup do
+      describe "#failed" do
+        before do
           @job.failed("OOOOPS!")
         end
 
-        should "set status" do
+        it "set status" do
           assert @job.status.failed?
         end
 
-        should "set message" do
+        it "set message" do
           assert_equal "OOOOPS!", @job.status.message
         end
       end
 
-      context "#completed" do
-        setup do
+      describe "#completed" do
+        before do
           @job.completed
         end
 
-        should "set status" do
+        it "set status" do
           assert @job.status.completed?
         end
 
-        should "set message" do
+        it "set message" do
           assert_match(/complete/i, @job.status.message)
         end
 
       end
 
-      context "#safe_perform!" do
-        setup do
+      describe "#safe_perform!" do
+        before do
           @job = ErrorJob.new("123")
           assert_raises(RuntimeError) do
             @job.safe_perform!
           end
         end
 
-        should "set status as failed" do
+        it "set status as failed" do
           assert @job.status.failed?
         end
       end

data/test/test_resque_plugins_status_hash.rb

@@ -1,9 +1,9 @@
 require 'test_helper'
 
-class TestResquePluginsStatusHash < Test::Unit::TestCase
+class TestResquePluginsStatusHash < Minitest::Test
 
-  context "Resque::Plugins::Status::Hash" do
-    setup do
+  describe "Resque::Plugins::Status::Hash" do
+    before do
       Resque.redis.flushall
       Resque::Plugins::Status::Hash.expire_in = nil
       @uuid = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid)
@@ -11,24 +11,24 @@ class TestResquePluginsStatusHash < Test::Unit::TestCase
       @uuid_with_json = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid, {"im" => "json"})
     end
 
-    context ".get" do
-      should "return the status as a Resque::Plugins::Status::Hash for the uuid" do
+    describe ".get" do
+      it "return the status as a Resque::Plugins::Status::Hash for the uuid" do
         status = Resque::Plugins::Status::Hash.get(@uuid)
         assert status.is_a?(Resque::Plugins::Status::Hash)
         assert_equal 'my status', status.message
       end
 
-      should "return nil if the status is not set" do
+      it "return nil if the status is not set" do
         assert_nil Resque::Plugins::Status::Hash.get('invalid_uuid')
       end
 
-      should "decode encoded json" do
+      it "decode encoded json" do
         assert_equal("json", Resque::Plugins::Status::Hash.get(@uuid_with_json)['im'])
       end
     end
 
-    context ".mget" do
-      should "return statuses as array of Resque::Plugins::Status::Hash for the uuids" do
+    describe ".mget" do
+      it "return statuses as array of Resque::Plugins::Status::Hash for the uuids" do
         uuid2 = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid)
         Resque::Plugins::Status::Hash.set(uuid2, "my status2")
         statuses = Resque::Plugins::Status::Hash.mget([@uuid, uuid2])
@@ -37,7 +37,7 @@ class TestResquePluginsStatusHash < Test::Unit::TestCase
         assert_equal ['my status', 'my status2'], statuses.map(&:message)
       end
 
-      should "return nil if a status is not set" do
+      it "return nil if a status is not set" do
         statuses = Resque::Plugins::Status::Hash.mget(['invalid_uuid', @uuid])
         assert_equal 2, statuses.size
         assert_nil statuses[0]
@@ -45,56 +45,56 @@ class TestResquePluginsStatusHash < Test::Unit::TestCase
         assert_equal 'my status', statuses[1].message
       end
 
-      should "decode encoded json" do
+      it "decode encoded json" do
         assert_equal ['json'],
           Resque::Plugins::Status::Hash.mget([@uuid_with_json]).map{|h| h['im']}
       end
     end
 
-    context ".set" do
+    describe ".set" do
 
-      should "set the status for the uuid" do
+      it "set the status for the uuid" do
         assert Resque::Plugins::Status::Hash.set(@uuid, "updated")
         assert_equal "updated", Resque::Plugins::Status::Hash.get(@uuid).message
       end
 
-      should "return the status" do
+      it "return the status" do
         assert Resque::Plugins::Status::Hash.set(@uuid, "updated").is_a?(Resque::Plugins::Status::Hash)
       end
 
     end
 
-    context ".create" do
-      should "add an item to a key set" do
+    describe ".create" do
+      it "add an item to a key set" do
         before = Resque::Plugins::Status::Hash.status_ids.length
         Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid)
         after = Resque::Plugins::Status::Hash.status_ids.length
         assert_equal 1, after - before
       end
 
-      should "return a uuid" do
+      it "return a uuid" do
         assert_match(/^\w{32}$/, Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid))
       end
 
-      should "store any status passed" do
+      it "store any status passed" do
         uuid = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid, "initial status")
         status = Resque::Plugins::Status::Hash.get(uuid)
         assert status.is_a?(Resque::Plugins::Status::Hash)
         assert_equal "initial status", status.message
       end
 
-      should "expire keys if expire_in is set" do
+      it "expire keys if expire_in is set" do
         Resque::Plugins::Status::Hash.expire_in = 1
         uuid = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid, "new status")
-        assert_contains Resque::Plugins::Status::Hash.status_ids, uuid
+        assert_includes Resque::Plugins::Status::Hash.status_ids, uuid
         assert_equal "new status", Resque::Plugins::Status::Hash.get(uuid).message
         sleep 2
         Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid)
-        assert_does_not_contain Resque::Plugins::Status::Hash.status_ids, uuid
+        refute_includes Resque::Plugins::Status::Hash.status_ids, uuid
         assert_nil Resque::Plugins::Status::Hash.get(uuid)
       end
 
-      should "store the options for the job created" do
+      it "store the options for the job created" do
         uuid = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid, "new", :options => {'test' => '123'})
         assert uuid
         status = Resque::Plugins::Status::Hash.get(uuid)
@@ -103,93 +103,93 @@ class TestResquePluginsStatusHash < Test::Unit::TestCase
       end
     end
 
-    context ".clear" do
-      setup do
+    describe ".clear" do
+      before do
         Resque::Plugins::Status::Hash.clear
       end
 
-      should "clear any statuses" do
+      it "clear any statuses" do
         assert_nil Resque::Plugins::Status::Hash.get(@uuid)
       end
 
-      should "clear any recent statuses" do
+      it "clear any recent statuses" do
         assert Resque::Plugins::Status::Hash.status_ids.empty?
       end
 
     end
 
-    context ".clear_completed" do
-      setup do
+    describe ".clear_completed" do
+      before do
         @completed_status_id = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid, {'status' => "completed"})
         @not_completed_status_id = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid)
         Resque::Plugins::Status::Hash.clear_completed
       end
 
-      should "clear completed status" do
+      it "clear completed status" do
         assert_nil Resque::Plugins::Status::Hash.get(@completed_status_id)
       end
 
-      should "not clear not-completed status" do
+      it "not clear not-completed status" do
         status = Resque::Plugins::Status::Hash.get(@not_completed_status_id)
         assert status.is_a?(Resque::Plugins::Status::Hash)
       end
     end
 
-    context ".clear_failed" do
-      setup do
+    describe ".clear_failed" do
+      before do
         @failed_status_id = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid, {'status' => "failed"})
         @not_failed_status_id = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid)
         Resque::Plugins::Status::Hash.clear_failed
       end
 
-      should "clear failed status" do
+      it "clear failed status" do
         assert_nil Resque::Plugins::Status::Hash.get(@failed_status_id)
       end
 
-      should "not clear not-failed status" do
+      it "not clear not-failed status" do
         status = Resque::Plugins::Status::Hash.get(@not_failed_status_id)
         assert status.is_a?(Resque::Plugins::Status::Hash)
       end
     end
 
-    context ".remove" do
-      setup do
+    describe ".remove" do
+      before do
         Resque::Plugins::Status::Hash.remove(@uuid)
       end
 
-      should "clear specify status" do
+      it "clear specify status" do
         assert_nil Resque::Plugins::Status::Hash.get(@uuid)
       end
     end
 
-    context ".status_ids" do
+    describe ".status_ids" do
 
-      setup do
+      before do
         @uuids = []
         30.times{ Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid) }
       end
 
-      should "return an array of job ids" do
+      it "return an array of job ids" do
         assert Resque::Plugins::Status::Hash.status_ids.is_a?(Array)
         assert_equal 32, Resque::Plugins::Status::Hash.status_ids.size # 30 + 2
       end
 
-      should "let you paginate through the statuses" do
+      it "let you paginate through the statuses" do
         assert_equal Resque::Plugins::Status::Hash.status_ids[0, 10], Resque::Plugins::Status::Hash.status_ids(0, 9)
         assert_equal Resque::Plugins::Status::Hash.status_ids[10, 10], Resque::Plugins::Status::Hash.status_ids(10, 19)
         # assert_equal Resque::Plugins::Status::Hash.status_ids.reverse[0, 10], Resque::Plugins::Status::Hash.status_ids(0, 10)
       end
     end
 
-    context ".statuses" do
+    describe ".statuses" do
 
-      should "return an array status objects" do
+      it "return an array status objects" do
         statuses = Resque::Plugins::Status::Hash.statuses
         assert statuses.is_a?(Array)
-        assert_same_elements [@uuid_with_json, @uuid], statuses.collect {|s| s.uuid }
+        assert_equal [@uuid_with_json, @uuid].sort, statuses.map(&:uuid).sort
       end
 
-      should "return an empty array when no statuses are available" do
+      it "return an empty array when no statuses are available" do
         Resque.redis.flushall
         statuses = Resque::Plugins::Status::Hash.statuses
         assert_equal [], statuses
@@ -198,18 +198,18 @@ class TestResquePluginsStatusHash < Test::Unit::TestCase
     end
 
     Resque::Plugins::Status::STATUSES.each do |status_code|
-      context ".#{status_code}?" do
+      describe ".#{status_code}?" do
 
-        setup do
+        before do
           uuid = Resque::Plugins::Status::Hash.create(Resque::Plugins::Status::Hash.generate_uuid, {'status' => status_code})
           @status = Resque::Plugins::Status::Hash.get(uuid)
         end
 
-        should "return true for the current status" do
+        it "return true for the current status" do
           assert @status.send("#{status_code}?"), status_code
         end
 
-        should "return false for other statuses" do
+        it "return false for other statuses" do
           (Resque::Plugins::Status::STATUSES - [status_code]).each do |other_status_code|
             assert !@status.send("#{other_status_code}?"), other_status_code
           end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resque-status
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Aaron Quint
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-12 00:00:00.000000000 Z
+date: 2015-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
@@ -90,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: quirkey
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: resque-status is an extension to the resque queue system that provides simple