elecnix-workling 0.4.2 → 0.4.9

data/test/invoker_eventmachine_subscription_test.rb

@@ -1,26 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-context "the invoker 'eventmachine subscription'" do
-  setup do
-    routing = Workling::Routing::ClassAndMethodRouting.new
-    @client_class = Workling::Clients::MemoryQueueClient
-    @client = @client_class.new
-    @client.connect
-    @invoker = Workling::Remote::Invokers::EventmachineSubscriber.new(routing, @client_class)
-  end
-  
-  specify "should invoke Util.echo with the arg 'hello' if the string 'hello' is set onto the queue utils__echo" do
-
-    # make sure all new instances point to the same client. that way, state is shared
-    Workling::Clients::MemoryQueueClient.expects(:new).at_least_once.returns @client
-    Util.any_instance.expects(:echo).once.with({ :message => "hello" })
-    
-    # Don't take longer than 10 seconds to shut this down. 
-    Timeout::timeout(10) do
-      listener = Thread.new { @invoker.listen }
-      @client.request("utils__echo", { :message => "hello" })
-      @invoker.stop
-      listener.join
-    end
-  end
-end

data/test/invoker_threaded_poller_test.rb

@@ -1,34 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-context "the invoker 'threaded poller'" do
-  setup do
-    routing = Workling::Routing::ClassAndMethodRouting.new
-    @client = Workling::Clients::MemoryQueueClient.new
-    @client.connect
-    @invoker = Workling::Remote::Invokers::ThreadedPoller.new(routing, @client.class)
-  end
-  
-  specify "should invoke Util.echo with the arg 'hello' if the string 'hello' is set onto the queue utils__echo" do
-    Util.any_instance.stubs(:echo).with("hello")
-    @client.request("utils__echo", "hello")
-    @invoker.dispatch!(@client, Util)
-  end
-  
-  specify "should not explode when listen is called, and stop nicely when stop is called. " do
-    connection = mock()
-    connection.expects(:active?).at_least_once.returns(true)
-    ActiveRecord::Base.expects(:connection).at_least_once.returns(connection)
-    
-    client = mock()
-    client.expects(:retrieve).at_least_once.returns("hi")
-    client.expects(:connect).at_least_once.returns(true)
-    Workling::Clients::MemoryQueueClient.expects(:new).at_least_once.returns(client)
-    
-    # Don't take longer than 10 seconds to shut this down. 
-    Timeout::timeout(10) do
-      listener = Thread.new { @invoker.listen }
-      @invoker.stop
-      listener.join
-    end
-  end
-end

data/test/memcachequeue_client_test.rb

@@ -1,36 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "The memcachequeue client" do
-  specify "should be able to connect to multiple queue instances" do
-    Workling.send :class_variable_set, "@@config", { :listens_on => "localhost:12345, 127.0.0.1:12346", :memcache_options => { :namespace => "myapp_development" } }
-    client = Workling::Clients::MemcacheQueueClient.new
-    client.connect
-    
-    client.queueserver_urls.should.equal ["localhost:12345", "127.0.0.1:12346"]
-    client.connection.servers.first.host.should == "localhost"
-    client.connection.servers.first.port.should == 12345    
-    client.connection.servers[1].host.should == "127.0.0.1"
-    client.connection.servers[1].port.should == 12346 
-    client.connection.namespace.should.equal "myapp_development"
-  end
-  
-  specify "should load it's config as well as any given MemCache options from RAILS_ENV/config/workling.yml" do
-    Workling.send :class_variable_set, "@@config", { :listens_on => "localhost:12345", :memcache_options => { :namespace => "myapp_development" } }
-    client = Workling::Clients::MemcacheQueueClient.new
-    client.connect
-    
-    client.queueserver_urls.should.equal ["localhost:12345"]
-    client.connection.servers.first.host.should == "localhost"
-    client.connection.servers.first.port.should == 12345    
-    client.connection.namespace.should.equal "myapp_development"
-  end
-  
-  
-  specify "should load it's config correctly if no memcache options are given" do
-    Workling.send :class_variable_set, "@@config", { :listens_on => "localhost:12345" }
-    client = Workling::Clients::MemcacheQueueClient.new
-    client.connect
-
-    client.queueserver_urls.should.equal ["localhost:12345"]
-  end  
-end

data/test/memory_return_store_test.rb

@@ -1,32 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-context "the memory return store" do
-  specify "should be able to store a value with a key, and then retrieve that same value with the same key." do
-    store = Workling::Return::Store::MemoryReturnStore.new
-    key, value = :gender, :undecided
-    store.set(key, value)
-    store.get(key).should.equal(value)
-  end
-  
-  specify "should delete values in the store once they have been get()tted." do
-    store = Workling::Return::Store::MemoryReturnStore.new
-    key, value = :gender, :undecided
-    store.set(key, value)
-    store.get(key)
-    store.get(key).should.equal nil
-  end
-  
-  specify "should return nothing for a key that is not in the store" do
-    store = Workling::Return::Store::MemoryReturnStore.new
-    store.get(:bollocks).should.equal nil
-  end
-  
-  specify "should be able to set and get two items into the same store" do
-    store = Workling::Return::Store::MemoryReturnStore.new
-    store.set(:gender, :male)
-    store.set(:gender, :female)
-    store.get(:key)
-    store.get(:key).should.equal :female
-  end
-
-end

data/test/mocks/client.rb

@@ -1,9 +0,0 @@
-require 'workling/clients/base'
-
-module Workling
-  module Clients
-    class MemcacheQueueClient < Workling::Clients::Base
-      def raise_unless_connected!; end
-    end
-  end
-end

data/test/mocks/logger.rb

@@ -1,5 +0,0 @@
-class Logger
-  def initialize(*args); end
-  def log(str); end
-  def error(str); end
-end

data/test/mocks/rude_queue.rb

@@ -1,9 +0,0 @@
-class RudeQueue
-  @@store = Hash.new(){ |hash, key| hash[key]=[] }
-  def self.get(queue_name)
-    @@store[queue_name.to_s].shift
-  end
-  def self.set(queue_name, value)
-    @@store[queue_name.to_s] << value
-  end
-end

data/test/mocks/spawn.rb

@@ -1,5 +0,0 @@
-module Spawn
-  def spawn(*args)
-    yield
-  end
-end

data/test/not_remote_runner_test.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "The not remote runner" do  
-  specify "should swallow exceptions raised in the workling" do
-    old_dispatcher = Workling::Remote.dispatcher
-    
-    Workling::Remote.dispatcher = Workling::Remote::Runners::NotRemoteRunner.new
-    Workling::Remote.run(:util, :faulty)
-    Workling::Remote.dispatcher = old_dispatcher # set back to whence we came
-  end
-end

data/test/remote_runner_test.rb

@@ -1,58 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-context "the remote runner" do
-  specify "should be able to invoke a task on a worker" do
-    Util.any_instance.stubs(:echo).with("hello")
-    Workling::Remote.run(:util, :echo, "hello")
-  end
-  
-  specify "should invoke the dispatcher set up in Workling::Remote.dispatcher" do
-    clazz, method, options = :util, :echo, { :message => "somebody_came@along.com" }
-    old_dispatcher = Workling::Remote.dispatcher
-    dispatcher = mock
-    dispatcher.expects(:run).with(clazz, method, options)
-    Workling::Remote.dispatcher = dispatcher
-    Workling::Remote.run(clazz, method, options)
-    Workling::Remote.dispatcher = old_dispatcher # set back to whence we came
-  end
-  
-  specify "should, when being tested, use the default remote runner by when no runner was explicitly set. " do
-    Workling::Remote.dispatcher.class.should.equal Workling.default_runner.class
-  end
-  
-  specify "should raise a Workling::WorklingNotFoundError if it is invoked with a worker key that cannot be constantized" do
-    should.raise Workling::WorklingNotFoundError do
-      Workling::Remote.run(:quatsch_mit_sosse, :fiddle_di_liddle)
-    end
-  end
-  
-  specify "should raise a Workling::WorklingNotFoundError if it is invoked with a valid worker key but the method is not defined on that worker" do
-    dispatcher = Workling::Remote.dispatcher
-    Workling::Remote.dispatcher = Workling::Remote::Runners::ThreadRunner.new # simulates a remote runner (workling in another context)
-    
-    should.raise Workling::WorklingNotFoundError do
-      Workling::Remote.run(:util, :sau_sack)
-    end
-    
-    Workling::Remote.dispatcher = dispatcher
-  end
-  
-  specify "should invoke work when called in this way: YourWorkling.asynch_your_method(options)" do
-    Util.any_instance.expects(:echo).once
-    Util.asynch_echo
-  end
-  
-  specify "should invoke work with the arguments intact when called in this way: YourWorkling.asynch_your_method(options)" do
-    stuffing = { :description => "toasted breadcrumbs with dill" }
-    Util.any_instance.expects(:stuffing).with(stuffing).once
-    Util.asynch_stuffing(stuffing)
-  end
-
-  specify "should use default arguments if they exist" do
-    default_options = { :flavor => 'purple' }
-    custom_options  = { :color  => 'purple' }
-    Util.any_instance.expects(:default_options).returns(default_options)
-    Util.any_instance.expects(:stuffing).with(all_of(has_entry(:flavor => 'purple'), has_entry(:color => 'purple'))).once
-    Util.asynch_stuffing(custom_options)
-  end
-end

data/test/rescue_test.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-context "Exceptions raised by worker" do
-  before do    
-    @old_dispatcher = Workling::Remote.dispatcher
-    Workling::Remote.dispatcher = Workling::Remote::Runners::NotRemoteRunner.new
-  end
-  after do
-    Workling::Remote.dispatcher = @old_dispatcher # set back to whence we came
-  end
-  
-  specify "should not escape dispatcher" do
-    lambda {
-      Workling::Remote.run(:util, :broken)
-    }.should.not.raise
-  end
-
-  specify "should call on_error method" do 
-    count = Util.on_error_call_count
-    Workling::Remote.run(:util, :broken)
-
-    Util.on_error_call_count.should.equal(count + 1)
-  end
-end

data/test/return_store_test.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "The return store" do
-  specify "should set a value on the current store when invoked like this: Workling::Return::Store.set(:key, 'value')" do
-    Workling::Return::Store.set(:key, :value)
-    Workling::Return::Store.get(:key).should.equal :value
-  end
-  
-  specify "should get a value on the current store when invoked like this: Workling::Return::Store.get(:key)" do
-    Workling::Return::Store.set(:key, :value)
-    Workling::Return::Store.get(:key).should.equal :value 
-  end
-  
-  specify "should set a value on the current store when invoked like this: Workling.return.set(:key, 'value')" do
-    Workling.return.set(:key, :value)
-    Workling.return.get(:key).should.equal :value
-  end
-  
-  specify "should return an iterator for a specific key when invoked like this: Workling.return.iterator(key)" do
-    Workling::Return::Store.set(:key, 1)
-    Workling::Return::Store.set(:key, 2)
-    Workling.return.iterator(:key).collect{ |item| item }.should.equal [1, 2]
-  end
-end

data/test/rudeq_client_test.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "The Rudeq client" do
-  specify "should by default set a RudeQueue as its :queue" do
-    client = Workling::Rudeq::Client.new
-    client.queue.should == RudeQueue
-  end
-  
-  specify "should user Rudeq.config[:queue_class] as the class" do
-    before = Workling::Rudeq.config[:queue_class]
-    
-    Workling::Rudeq.config[:queue_class] = "String"
-    client = Workling::Rudeq::Client.new
-    client.queue.should == String
-    
-    Workling::Rudeq.config[:queue_class] = before
-  end
-
-  specify "should defer :get to the RudeQueue" do
-    RudeQueue.expects(:get).with(:abc)
-    client = Workling::Rudeq::Client.new
-    client.get(:abc)
-  end
-  
-  specify "should defer :set to the RudeQueue" do
-    RudeQueue.expects(:set).with(:abc, "some value")
-    client = Workling::Rudeq::Client.new
-    client.set(:abc, "some value")
-  end
-end

data/test/rudeq_poller_test.rb

@@ -1,14 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-context "the RudeQ poller" do
-  setup do
-    routing = Workling::Starling::Routing::ClassAndMethodRouting.new
-    @client = Workling::Rudeq::Poller.new(routing)
-  end
-  
-  specify "should invoke Util.echo with the arg 'hello' if the string 'hello' is set onto the queue utils__echo" do
-    Util.any_instance.expects(:echo).with("hello")
-    RudeQueue.set("utils__echo", "hello")
-    @client.dispatch!(RudeQueue, Util)
-  end
-end

data/test/rudeq_return_store_test.rb

@@ -1,20 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "the RudeQ return store" do
-
-  def get_store
-    Workling::Return::Store::RudeqReturnStore.new
-  end
-  
-  specify "should defer :get to the RudeQueue" do
-    RudeQueue.expects(:get).with(:abc)
-    store = get_store
-    store.get(:abc)
-  end
-  
-  specify "should defer :set to the RudeQueue" do
-    RudeQueue.expects(:set).with(:abc, "some value")
-    store = get_store
-    store.set(:abc, "some value")
-  end
-end

data/test/rudeq_runner_test.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-context "the RudeQ runner" do
-  setup do
-    @before = Workling::Remote.dispatcher
-  end
-  
-  specify "should set up a RudeQ client" do
-    Workling::Remote.dispatcher = Workling::Remote::Runners::RudeqRunner.new
-    Workling::Remote.dispatcher.client.should.not.equal nil
-    Workling::Remote.dispatcher.client.queue.should.equal RudeQueue
-  end
-
-  specify ":run should use Starling routing" do
-    RudeQueue.expects(:set).with("utils__echo", "hello")
-    Workling::Remote::Runners::RudeqRunner.new.run(Util, :echo, "hello")
-  end
-  
-  teardown do
-    Workling::Remote.dispatcher = @before
-  end
-end

data/test/runners/thread_runner.rb

@@ -1,22 +0,0 @@
-require 'workling/remote/runners/base'
-
-#
-#  Spawns a Thread. Used for Tests only, to simulate a remote runner more realistically. 
-#
-module Workling
-  module Remote
-    module Runners
-      class ThreadRunner < Workling::Remote::Runners::Base
-        
-        # spawns a thread. 
-        def run(clazz, method, options = {})
-          Thread.new {
-            dispatch!(clazz, method, options) 
-          }
-                    
-          return nil
-        end
-      end
-    end
-  end
-end

data/test/spawn_runner_test.rb

@@ -1,10 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-context "the spawn runner" do  
-  specify "should invoke work that is delegated to it" do
-    old_dispatcher = Workling::Remote.dispatcher
-    Workling::Remote.dispatcher = Workling::Remote::Runners::SpawnRunner.new
-    Workling::Remote.run(:util, :echo)
-    Workling::Remote.dispatcher = old_dispatcher
-  end
-end

data/test/starling_return_store_test.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "the starling return store" do
-  setup do
-    # the memoryreturnstore behaves exactly like memcache. 
-    MemCache.expects(:new).at_least(0).returns Workling::Return::Store::MemoryReturnStore.new
-    Workling::Clients::MemcacheQueueClient.expects(:connection).at_least(0).returns Workling::Return::Store::MemoryReturnStore.new
-  end
-  
-  specify "should be able to store a value with a key, and then retrieve that same value with the same key." do
-    store = Workling::Return::Store::StarlingReturnStore.new
-    key, value = :gender, :undecided
-    store.set(key, value)
-    store.get(key).should.equal(value)
-  end
-  
-  specify "should delete values in the store once they have been get()tted." do
-    store = Workling::Return::Store::StarlingReturnStore.new
-    key, value = :gender, :undecided
-    store.set(key, value)
-    store.get(key)
-    store.get(key).should.equal nil
-  end
-  
-  specify "should return nothing for a key that is not in the store" do
-    store = Workling::Return::Store::StarlingReturnStore.new
-    store.get(:bollocks).should.equal nil
-  end
-end