backgrounded 0.7.5 → 2.0.0.pre1

data/.rvmrc

@@ -1,4 +1,4 @@
-rvm use ree-1.8.7@backgrounded --create
+rvm use 1.9.3@backgrounded --create
 if ! command -v bundle ; then
   gem install bundler
   bundle install --local

data/README.rdoc

@@ -11,27 +11,21 @@ Backgrounded provides a thin wrapper around any background processing framework
 
 = Usage
 
-  #declaration
   class User
-    backgrounded :do_stuff
     def do_stuff
-      # do all your work here
+    end
+    def self.do_something_else
     end
   end
 
-  #usage
   user = User.new
-  user.do_stuff_backgrounded
-
-= Installation
-
-Command line installation
+  # execute instance method in background
+  user.backgrounded.do_stuff
 
-  sudo gem install backgrounded
+  # execute class method in background
+  User.backgrounded.do_something_else
 
-Rails environment.rb configuration
-
-  config.gem 'backgrounded'
+= Installation
 
 Bundler Gemfile configuration
 
@@ -39,30 +33,14 @@ Bundler Gemfile configuration
 
 = Configuration
 
-Backgrounded includes several configurable implementations out of the box for most popular background frameworks.
-If your framework isn't included, it's trivial to write your own implementation.  
-Submit a patch and we may consider it for official distribution!
-
-== DelayedJob
-see http://github.com/tobi/delayed_job/tree/master
-
-  # config/initializers/backgrounded.rb
-  require 'backgrounded/handler/delayed_job_handler'
-  Backgrounded.handler = Backgrounded::Handler::DelayedJobHandler.new
+Backgrounded packages handlers for popular frameworks in separate gems.  Just drop in the gem for your particular framework or write your own!
 
 == Resque
-see http://github.com/defunkt/resque/
-
-  # config/initializers/backgrounded.rb
-  require 'backgrounded/handler/resque_handler'
-  Backgrounded.handler = Backgrounded::Handler::ResqueHandler.new
+see http://github.com/wireframe/backgrounded-resque
 
 == JobFu
 see http://github.com/jnstq/job_fu/tree
 
-  # config/initializers/backgrounded.rb
-  Backgrounded.handler = JobFu::Backgrounded::Handler.new
-
 == Custom Handlers
 
   # config/initializers/backgrounded.rb
@@ -75,4 +53,4 @@ see http://github.com/jnstq/job_fu/tree
 
 == Copyright
 
-Copyright (c) 2009 Ryan Sonnek. See LICENSE for details.
+Copyright (c) 2012 Ryan Sonnek. See LICENSE for details.

data/backgrounded.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.authors     = ["Ryan Sonnek"]
   s.email       = ["ryan@codecrate.com"]
   s.homepage    = "http://github.com/wireframe/backgrounded"
-  s.summary     = %q{Simple API to run Model methods in the background}
+  s.summary     = %q{Simple API to perform work in the background}
   s.description = %q{Execute any ActiveRecord Model method in the background}
 
   s.rubyforge_project = "backgrounded"
@@ -17,11 +17,8 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency(%q<activerecord>, [">= 2.3.10"])
   s.add_runtime_dependency(%q<activesupport>, [">= 2.3.10"])
   s.add_development_dependency(%q<shoulda>, [">= 0"])
-  s.add_development_dependency(%q<resque>, [">= 0.17.1"])
-  s.add_development_dependency(%q<resque_unit>, [">= 0.3.7"])
   s.add_development_dependency(%q<mocha>, [">= 0"])
   s.add_development_dependency(%q<sqlite3-ruby>, [">= 1.3.2"])
-  s.add_development_dependency(%q<delayed_job>, [">= 2.1.4"])
   s.add_development_dependency(%q<rake>, [">= 0.9.2.2"])
 
   s.files         = `git ls-files`.split("\n")

data/lib/backgrounded.rb

@@ -1,20 +1,30 @@
 require 'active_support/all'
 
-require File.join(File.dirname(__FILE__), 'backgrounded', 'class_methods')
 require File.join(File.dirname(__FILE__), 'backgrounded', 'handler', 'inprocess_handler')
-
-Object.send(:include, Backgrounded::ClassMethods)
+require File.join(File.dirname(__FILE__), 'backgrounded', 'proxy')
 
 module Backgrounded
+  extend ActiveSupport::Concern
+
   class << self
     attr_accessor :logger, :handler
-    def method_name_for_backgrounded_options(method_name)
-      method_basename, punctuation = method_name.to_s.sub(/([?!=])$/, ''), $1
-      "#{method_basename}_backgrounded_options"
+  end
+
+  module ClassMethods
+    def backgrounded(options={})
+      Backgrounded::Proxy.new self, options
     end
   end
+
+  # @param options (optional) options to pass into the backgrounded handler
+  def backgrounded(options={})
+    Backgrounded::Proxy.new self, options
+  end
 end
 
+# include backgrounded into any ruby object
+Object.send(:include, Backgrounded)
+
 # default handler to the basic in process handler
 Backgrounded.handler = Backgrounded::Handler::InprocessHandler.new
 

data/lib/backgrounded/handler/inprocess_handler.rb

@@ -3,7 +3,7 @@ module Backgrounded
     #simple handler to process synchronously and not actually in the background
     #useful for testing
     class InprocessHandler
-      def request(object, method, *args)
+      def request(object, method, args, options={})
         object.send method, *args
       end
     end

data/lib/backgrounded/handler/no_op_handler.rb

@@ -3,7 +3,7 @@ module Backgrounded
     # throw requests out the window
     # useful for test environment to avoid any background work
     class NoOpHandler
-      def request(object, method, *args)
+      def request(object, method, args, options={})
         # do nothing
       end
     end

data/lib/backgrounded/proxy.rb

@@ -0,0 +1,14 @@
+module Backgrounded
+  class Proxy
+    def initialize(delegate, options={})
+      @delegate = delegate
+      @options = options
+    end
+
+    def method_missing(method_name, *args)
+      Backgrounded.logger.debug("Requesting #{Backgrounded.handler} backgrounded method: #{method_name} for instance #{@delegate}")
+      Backgrounded.handler.request(@delegate, method_name, args, @options)
+      nil
+    end
+  end
+end

data/lib/backgrounded/version.rb

@@ -1,3 +1,3 @@
 module Backgrounded
-  VERSION = "0.7.5"
+  VERSION = "2.0.0.pre1"
 end

data/test/backgrounded_test.rb

@@ -1,154 +1,45 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
 class BackgroundedTest < Test::Unit::TestCase
-  
-  class User
-    backgrounded :do_stuff
-
-    def do_stuff
-    end
-  end
-
-  class Person
-    backgrounded :do_stuff
-
-    def do_stuff(name, place, location)
-    end
-  end
-
-  class Post
-    backgrounded :do_stuff, :notify_users
 
+  class User
     def do_stuff
     end
-    def notify_users
+    def self.do_something_else
     end
   end
 
-  class Comment
-    backgrounded :delete_spam!
-
-    def delete_spam!
+  context '#backgrounded' do
+    should 'be defined for class' do
+      assert User.respond_to?(:backgrounded)
     end
-  end
-
-  class Dog
-    backgrounded :bark => {:priority => :low}
-
-    def bark
+    should 'be defined for instance' do
+      assert User.new.respond_to?(:backgrounded)
     end
-  end
-
-  class Entry
-    backgrounded :do_stuff
-    backgrounded :notify_users
-
-    def do_stuff
-    end
-    def notify_users
-    end
-  end
-
-  class Blog
-    class << self
-      backgrounded :update_info
-      def update_info
+    context 'invoking on class' do
+      setup do
+        @result = User.backgrounded
+      end
+      should 'return instance of Backgrounded::Proxy' do
+        assert @result.is_a?(Backgrounded::Proxy)
       end
     end
-  end
-
-  context 'an object with a single backgrounded method' do
-    setup do
-      @user = User.new
-    end
-    should 'define backgrounded method' do
-      assert @user.respond_to?('do_stuff_backgrounded')
-    end
-    should 'define backgrounded_options method' do
-      assert @user.respond_to?('do_stuff_backgrounded_options')
-    end
-    should 'save backgrounded options for method' do
-      assert_equal({}, @user.do_stuff_backgrounded_options)
-    end
-    context 'executing backgrounded method' do
+    context 'invoking on an instance' do
       setup do
-        @user.expects(:do_stuff).returns(true)
-        @result = @user.do_stuff_backgrounded
+        @user = User.new
+        @result = @user.backgrounded
       end
-      should "execute method in background" do end #see expectations
-      should 'return nil for backgrounded method' do
-        assert_nil @result
+      should 'return instance of Backgrounded::Proxy' do
+        assert @result.is_a?(Backgrounded::Proxy)
       end
     end
-  end
-
-  context 'an object with a backgrounded method that accepts parameters' do
-    setup do
-      @person = Person.new
-    end
-    should 'forward them' do
-      @person.expects(:do_stuff).with('ryan', 2, 3)
-      @person.do_stuff_backgrounded('ryan', 2, 3)
-    end
-  end
-  
-  context 'an object with a backgrounded method included punctuation' do
-    setup do
-      @comment = Comment.new
-    end
-    should 'move punctuation to the end of the new method' do
-      assert @comment.respond_to?(:'delete_spam_backgrounded!')
-    end
-  end
-
-  context 'an object with multiple backgrounded methods' do
-    setup do
-      @post = Post.new
-    end
-    should "execute method either method in background" do
-      @post.expects(:do_stuff)
-      @post.do_stuff_backgrounded
-
-      @post.expects(:notify_users)
-      @post.notify_users_backgrounded
-    end
-  end
-
-  context 'an object with multiple backgrounded invokations' do
-    setup do
-      @post = Entry.new
-    end
-    should "setup options for both methods" do
-      assert_equal({}, @post.do_stuff_backgrounded_options)
-      assert_equal({}, @post.notify_users_backgrounded_options)
-    end
-  end
-
-  context 'an object with backgrounded method options' do
-    setup do
-      @dog = Dog.new
-    end
-    should 'save method options for future use' do
-      assert_equal({:priority => :low}, @dog.bark_backgrounded_options)
-    end
-  end
-
-  context 'a class with backgrounded method' do
-    should 'define backgrounded method' do
-      assert Blog.respond_to?('update_info_backgrounded')
-    end
-    should 'defined backgrounded_options method' do
-      assert Blog.respond_to?('update_info_backgrounded_options')
-    end
-    should 'save backgrounded options for method' do
-      assert_equal({}, Blog.update_info_backgrounded_options)
-    end
-    context 'invoking backgrounded method' do
+    context 'invoking with options' do
       setup do
-        Blog.expects(:update_info)
-        Blog.update_info_backgrounded
+        @result = User.backgrounded(:priority => :high)
+      end
+      should 'initialize proxy with options' do
+        assert_equal({:priority => :high}, @result.instance_variable_get(:@options))
       end
-      should 'invoke class method' do end #see expectations
     end
   end
 end

data/test/proxy_test.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ProxyTest < Test::Unit::TestCase
+
+  class User
+    def do_stuff
+    end
+    def self.do_something_else
+    end
+  end
+
+  class Person
+    def do_stuff(name, place, location)
+    end
+  end
+
+  context 'invoking delegate method' do
+    context 'with arguments' do
+      setup do
+        @delegate = Person.new
+        @delegate.expects(:do_stuff).with('foo', 1, 'bar')
+        @proxy = Backgrounded::Proxy.new @delegate
+        @result = @proxy.do_stuff 'foo', 1, 'bar'
+      end
+      should "execute method on delegate" do end #see expectations
+      should 'return nil' do
+        assert_nil @result
+      end
+    end
+    context 'with no arguments' do
+      setup do
+        @delegate = User.new
+        @delegate.expects(:do_stuff)
+        @proxy = Backgrounded::Proxy.new @delegate
+        @result = @proxy.do_stuff
+      end
+      should "execute method on delegate" do end #see expectations
+    end
+    context 'context when proxy is configured with options' do
+      setup do
+        Backgrounded.handler.expects(:request).with(anything, anything, anything, {:priority => :high})
+        @delegate = User
+        @proxy = Backgrounded::Proxy.new @delegate, :priority => :high
+        @proxy.do_something_else
+      end
+      should 'pass options onto Backgrounded.handler' do end # see expectations
+    end
+  end
+end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: backgrounded
 version: !ruby/object:Gem::Version
-  version: 0.7.5
-  prerelease: 
+  version: 2.0.0.pre1
+  prerelease: 6
 platform: ruby
 authors:
 - Ryan Sonnek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-04 00:00:00.000000000 Z
+date: 2012-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &2183008840 !ruby/object:Gem::Requirement
+  requirement: &2178080800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 2.3.10
   type: :runtime
   prerelease: false
-  version_requirements: *2183008840
+  version_requirements: *2178080800
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2183008320 !ruby/object:Gem::Requirement
+  requirement: &2178080260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 2.3.10
   type: :runtime
   prerelease: false
-  version_requirements: *2183008320
+  version_requirements: *2178080260
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &2183007840 !ruby/object:Gem::Requirement
+  requirement: &2178079780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,32 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2183007840
-- !ruby/object:Gem::Dependency
-  name: resque
-  requirement: &2183007360 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.17.1
-  type: :development
-  prerelease: false
-  version_requirements: *2183007360
-- !ruby/object:Gem::Dependency
-  name: resque_unit
-  requirement: &2183006880 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.3.7
-  type: :development
-  prerelease: false
-  version_requirements: *2183006880
+  version_requirements: *2178079780
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &2183006400 !ruby/object:Gem::Requirement
+  requirement: &2178079300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2183006400
+  version_requirements: *2178079300
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
-  requirement: &2183005920 !ruby/object:Gem::Requirement
+  requirement: &2178078820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,21 +65,10 @@ dependencies:
         version: 1.3.2
   type: :development
   prerelease: false
-  version_requirements: *2183005920
-- !ruby/object:Gem::Dependency
-  name: delayed_job
-  requirement: &2183005440 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.1.4
-  type: :development
-  prerelease: false
-  version_requirements: *2183005440
+  version_requirements: *2178078820
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2183004960 !ruby/object:Gem::Requirement
+  requirement: &2178078340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,7 +76,7 @@ dependencies:
         version: 0.9.2.2
   type: :development
   prerelease: false
-  version_requirements: *2183004960
+  version_requirements: *2178078340
 description: Execute any ActiveRecord Model method in the background
 email:
 - ryan@codecrate.com
@@ -125,19 +92,13 @@ files:
 - Rakefile
 - backgrounded.gemspec
 - lib/backgrounded.rb
-- lib/backgrounded/class_methods.rb
-- lib/backgrounded/handler/delayed_job_handler.rb
 - lib/backgrounded/handler/inprocess_handler.rb
 - lib/backgrounded/handler/no_op_handler.rb
-- lib/backgrounded/handler/pseudo_resque_handler.rb
-- lib/backgrounded/handler/resque_handler.rb
-- lib/backgrounded/handler/workling_handler.rb
+- lib/backgrounded/proxy.rb
 - lib/backgrounded/version.rb
-- test/backgrounded/handler/delayed_job_handler_test.rb
-- test/backgrounded/handler/resque_handler_test.rb
-- test/backgrounded/handler/workling_handler_test.rb
 - test/backgrounded_test.rb
 - test/database.yml
+- test/proxy_test.rb
 - test/test_helper.rb
 homepage: http://github.com/wireframe/backgrounded
 licenses: []
@@ -153,26 +114,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -49604688935868797
+      hash: -2552094692552709134
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -49604688935868797
+      version: 1.3.1
 requirements: []
 rubyforge_project: backgrounded
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: Simple API to run Model methods in the background
+summary: Simple API to perform work in the background
 test_files:
-- test/backgrounded/handler/delayed_job_handler_test.rb
-- test/backgrounded/handler/resque_handler_test.rb
-- test/backgrounded/handler/workling_handler_test.rb
 - test/backgrounded_test.rb
 - test/database.yml
+- test/proxy_test.rb
 - test/test_helper.rb

data/lib/backgrounded/class_methods.rb

@@ -1,23 +0,0 @@
-module Backgrounded
-  module ClassMethods
-    def backgrounded(*args)
-      options = args.extract_options!
-      methods_with_options = args.inject({}) do |hash, method| hash[method] = {}; hash end
-      methods_with_options.merge! options
-      methods_with_options.each_pair do |method, options|
-        method_basename, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
-        backgrounded_method = "#{method_basename}_backgrounded#{punctuation}"
-        class_eval do
-          define_method backgrounded_method do |*args|
-            Backgrounded.logger.debug("Requesting #{Backgrounded.handler} backgrounded method: #{method} for instance #{self}")
-            Backgrounded.handler.request(self, method, *args)
-            nil
-          end
-          define_method Backgrounded.method_name_for_backgrounded_options(method) do
-            options
-          end
-        end
-      end
-    end
-  end
-end

data/lib/backgrounded/handler/delayed_job_handler.rb

@@ -1,13 +0,0 @@
-require 'delayed_job'
-
-module Backgrounded
-  module Handler
-    # invoke the operation in the background using delayed job
-    # see http://github.com/tobi/delayed_job/tree/master
-    class DelayedJobHandler
-      def request(object, method, *args)
-        object.send_later(method.to_sym, *args)
-      end
-    end
-  end
-end

data/lib/backgrounded/handler/pseudo_resque_handler.rb

@@ -1,14 +0,0 @@
-require 'resque'
-
-# handler that acts like the in process handler but marshalls the arguments
-# this simulates how resque encodes/decodes values to/from redis
-# useful when passing symbols to arguments and they end up being processed as strings
-module Backgrounded
-  module Handler
-    class PseudoResqueHandler
-      def request(object, method, *args)
-        object.send method, *Resque.decode(Resque.encode(args))
-      end
-    end
-  end
-end

data/lib/backgrounded/handler/resque_handler.rb

@@ -1,38 +0,0 @@
-require 'resque'
-
-module Backgrounded
-  module Handler
-    #enque requests in resque
-    class ResqueHandler
-      DEFAULT_QUEUE = 'backgrounded'
-      INVALID_ID = -1
-      @@queue = DEFAULT_QUEUE
-
-      def request(object, method, *args)
-        options = object.send Backgrounded.method_name_for_backgrounded_options(method)
-        @@queue = options[:queue] || DEFAULT_QUEUE
-        instance, id = instance_identifiers(object)
-        Resque.enqueue(ResqueHandler, instance, id, method, *args)
-      end
-      def self.queue
-        @@queue
-      end
-      def self.perform(clazz, id, method, *args)
-        find_instance(clazz, id, method).send(method, *args)
-      end
-
-      private
-      def self.find_instance(clazz, id, method)
-        clazz = clazz.constantize
-        id.to_i == INVALID_ID ? clazz : clazz.find(id)
-      end
-      def instance_identifiers(object)
-        instance, id = if object.kind_of?(ActiveRecord::Base)
-          [object.class.name, object.id]
-        else
-          [object.name, INVALID_ID]
-        end
-      end
-    end
-  end
-end

data/lib/backgrounded/handler/workling_handler.rb

@@ -1,34 +0,0 @@
-class Backgrounded::Handler::WorklingHandler
-  class BackgroundedWorker < Workling::Base
-    INVALID_ID = -1
-    def perform(options = {})
-      find_instance(options[:class], options[:id], options[:method]).send(options[:method], *options[:params])
-    end
-
-    private
-    def find_instance(clazz, id, method)
-      clazz = clazz.constantize
-      id.to_i == INVALID_ID ? clazz : clazz.find(id)
-    end
-  end
-
-  def request(object, method, *args)
-    instance, id = instance_identifiers(object)
-    options = {
-      :class => instance,
-      :id => id,
-      :method => method,
-      :params => args
-    }
-    BackgroundedWorker.async_perform options
-  end
-
-  private
-  def instance_identifiers(object)
-    instance, id = if object.is_a?(Class) 
-      [object.name, INVALID_ID]
-    else
-      [object.class.name, object.id]
-    end
-  end
-end

data/test/backgrounded/handler/delayed_job_handler_test.rb

@@ -1,56 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-require 'backgrounded/handler/delayed_job_handler'
-require 'delayed/backend/active_record'
-
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :users, :force => true do |t|
-    t.column :name, :string
-  end
-  create_table :delayed_jobs, :force => true do |table|
-    table.integer  :priority, :default => 0      # Allows some jobs to jump to the front of the queue
-    table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
-    table.text     :handler                      # YAML-encoded string of the object that will do work
-    table.string   :last_error                   # reason for last failure (See Note below)
-    table.datetime :run_at                       # When to run. Could be Time.now for immediately, or sometime in the future.
-    table.datetime :locked_at                    # Set when a client is working on this object
-    table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
-    table.string   :locked_by                    # Who is working on this object (if locked)
-    table.timestamps
-  end
-end
-
-class DelayedJobHandlerTest < Test::Unit::TestCase
-
-  class User < ActiveRecord::Base
-    backgrounded :do_stuff
-
-    def do_stuff
-    end
-  end
-
-  context 'when backgrounded is configured with delayed_job' do
-    setup do
-      Delayed::Worker.backend = :active_record
-      @handler = Backgrounded::Handler::DelayedJobHandler.new
-      Backgrounded.handler = @handler
-    end
-
-    should 'be configured' do
-      fail 'delayed job not recognizing activerecord config'
-    end
-    # context 'a persisted object with a single backgrounded method' do
-    #   setup do
-    #     @user = User.create
-    #   end
-    #   context "invoking backgrounded method" do
-    #     setup do
-    #       @user.do_stuff_backgrounded
-    #     end
-    #     should_create Delayed::Job
-    #     should 'create delayed job' do
-    #       job = Delayed::Job.last
-    #     end
-    #   end
-    # end
-  end
-end

data/test/backgrounded/handler/resque_handler_test.rb

@@ -1,154 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-require 'backgrounded/handler/resque_handler'
-require 'resque_unit'
-
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :blogs, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :users, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :posts, :force => true do |t|
-    t.column :title, :string
-  end
-end
-
-class ResqueHandlerTest < Test::Unit::TestCase
-  class User < ActiveRecord::Base
-    backgrounded :do_stuff
-
-    def do_stuff
-    end
-  end
-
-  class Post < ActiveRecord::Base
-    backgrounded :do_stuff => {:queue => 'important'}
-
-    def do_stuff
-    end
-  end
-
-  class Blog < ActiveRecord::Base
-    class << self
-      backgrounded :do_stuff
-
-      def do_stuff
-      end
-    end
-    backgrounded :do_stuff
-    def do_stuff
-    end
-  end
-
-  module Foo
-    class << self
-      backgrounded :bar
-      def bar
-      end
-    end
-  end
-
-  context 'when backgrounded is configured with resque' do
-    setup do
-      Resque.reset!
-      @handler = Backgrounded::Handler::ResqueHandler.new
-      Backgrounded.handler = @handler
-    end
-
-    context 'a class level backgrounded method' do
-      context "invoking backgrounded method" do
-        setup do
-          Blog.do_stuff_backgrounded
-        end
-        should "enqueue job to resque" do
-          assert_queued Backgrounded::Handler::ResqueHandler, [Blog.to_s, -1, 'do_stuff']
-          assert_equal Backgrounded::Handler::ResqueHandler::DEFAULT_QUEUE, Resque.queue_from_class(Backgrounded::Handler::ResqueHandler)
-        end
-        context "running background job" do
-          setup do
-            Blog.expects(:do_stuff)
-            Resque.run!
-          end
-          should "invoke method on class" do end #see expectations
-        end
-      end
-      context 'with an instance level backgrounded method of the same name' do
-        setup do
-          @blog = Blog.create
-          @blog.do_stuff_backgrounded
-        end
-        should "enqueue instance method job to resque" do
-          assert_queued Backgrounded::Handler::ResqueHandler, [Blog.to_s, @blog.id, 'do_stuff']
-          assert_equal Backgrounded::Handler::ResqueHandler::DEFAULT_QUEUE, Resque.queue_from_class(Backgrounded::Handler::ResqueHandler)
-        end
-        context "running background job" do
-          setup do
-            Blog.expects(:do_stuff).never
-            Blog.any_instance.expects(:do_stuff)
-            Resque.run!
-          end
-          should "invoke method on instance" do end #see expectations
-        end
-      end
-    end
-
-    context 'a persisted object with a single backgrounded method' do
-      setup do
-        @user = User.create
-      end
-      context "invoking backgrounded method" do
-        setup do
-          @user.do_stuff_backgrounded
-        end
-        should "enqueue job to resque" do
-          assert_queued Backgrounded::Handler::ResqueHandler, [User.to_s, @user.id, 'do_stuff']
-          assert_equal Backgrounded::Handler::ResqueHandler::DEFAULT_QUEUE, Resque.queue_from_class(Backgrounded::Handler::ResqueHandler)
-        end
-        context "running background job" do
-          should "invoke method on user object" do
-            User.any_instance.expects(:do_stuff)
-            Resque.run!
-          end
-        end
-      end
-
-      context 'a persisted object with backgrounded method with options' do
-        setup do
-          @post = Post.create
-        end
-        context "invoking backgrounded method" do
-          setup do
-            @post.do_stuff_backgrounded
-          end
-          should "use configured queue" do
-            assert_equal 'important', Backgrounded::Handler::ResqueHandler.queue
-            assert_equal 'important', Resque.queue_from_class(Backgrounded::Handler::ResqueHandler)
-            assert_equal 1, Resque.queue('important').length
-          end
-        end
-      end
-    end
-
-    context 'with a module backgrounded class method' do
-      context 'when invoking class method backgrounded' do
-        setup do
-          Foo.bar_backgrounded
-        end
-        should "enqueue job to resque" do
-          assert_queued Backgrounded::Resque::ResqueHandler, [Foo.to_s, -1, 'bar']
-          assert_equal Backgrounded::Resque::ResqueHandler::DEFAULT_QUEUE, Resque.queue_from_class(Backgrounded::Resque::ResqueHandler)
-        end
-        context 'when processing job' do
-          setup do
-            Foo.expects(:bar)
-            Resque.run!
-          end
-          should 'invoke module class method backgrounded' do end # see expectations
-        end
-      end
-    end
-  end
-end

data/test/backgrounded/handler/workling_handler_test.rb

@@ -1,68 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-# RAILS_DEFAULT_LOGGER = Logger.new STDOUT
-# RAILS_ENV = 'test'
-# require 'newrelic_rpm'
-# require 'memcache'
-# require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'socialcast', 'vendor', 'plugins', 'workling', 'lib', 'workling')
-# require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'socialcast', 'vendor', 'plugins', 'workling', 'lib', 'workling', 'base')
-# require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'socialcast', 'vendor', 'plugins', 'workling', 'lib', 'workling', 'discovery')
-# require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'socialcast', 'vendor', 'plugins', 'workling', 'lib', 'workling', 'routing', 'class_and_method_routing')
-# require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'socialcast', 'vendor', 'plugins', 'workling', 'lib', 'workling', 'remote', 'invokers', 'threaded_poller')
-# require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'socialcast', 'vendor', 'plugins', 'workling', 'lib', 'workling', 'remote')
-# require 'backgrounded/handler/workling_handler'
-
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :users, :force => true do |t|
-    t.column :name, :string
-  end
-end
-
-class WorklingHandlerTest < Test::Unit::TestCase
-
-  class User < ActiveRecord::Base
-    backgrounded :do_stuff
-
-    def do_stuff
-    end
-  end
-
-  class Post < ActiveRecord::Base
-    class << self
-      backgrounded :do_stuff
-
-      def do_stuff
-      end
-    end
-  end
-
-  context 'when backgrounded is configured with workling' do
-    setup do
-      fail 'workling not available as a gem'
-      @handler = Backgrounded::Handler::WorklingHandler.new
-      Backgrounded.handler = @handler
-    end
-
-    context 'a persisted object with a single backgrounded method' do
-      setup do
-        @user = User.create
-      end
-      context "invoking backgrounded method" do
-        setup do
-          User.any_instance.expects(:do_stuff).with('a string')
-          @user.do_stuff_backgrounded 'a string'
-        end
-        should 'dispatch through workling back to the object' do end #see expectations
-      end
-    end
-
-    context 'a class level backgrounded method' do
-      context "invoking backgrounded method" do
-        setup do
-          Post.expects(:do_stuff).with('a string')
-          Post.do_stuff_backgrounded 'a string'
-        end
-        should 'dispatch through workling back to the object' do end #see expectations
-      end
-    end
-  end
-end