elecnix-workling 0.3.1

data/test/class_and_method_routing_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "class and method routing" do
+  specify "should create a queue called utils:echo for a Util class that subclasses worker and has the method echo" do
+    routing = Workling::Routing::ClassAndMethodRouting.new  
+    routing['utils__echo'].class.to_s.should.equal "Util"
+  end
+  
+  specify "should create a queue called analytics:invites:sent for an Analytics::Invites class that subclasses worker and has the method sent" do
+    routing = Workling::Routing::ClassAndMethodRouting.new
+    routing['analytics__invites__sent'].class.to_s.should.equal "Analytics::Invites"
+  end
+  
+  specify "queue_names_routing_class should return all queue names associated with a class" do
+    routing = Workling::Routing::ClassAndMethodRouting.new
+    routing.queue_names_routing_class(Util).should.include 'utils__echo'
+  end
+end

data/test/clients/memory_queue_client.rb

@@ -0,0 +1,36 @@
+require 'workling/clients/base'
+
+module Workling
+  module Clients
+    class MemoryQueueClient < Workling::Clients::Base
+      
+      def initialize
+        @subscribers ||= {}
+        @queues ||= {}
+      end
+      
+      # collects the worker blocks in a hash
+      def subscribe(work_type, &block)
+        @subscribers[work_type] = block
+      end
+      
+      # immediately invokes the required worker block
+      def request(work_type, arguments)
+        if subscription = @subscribers[work_type]
+          subscription.call(arguments)
+        else
+          @queues[work_type] ||= []
+          @queues[work_type] << arguments
+        end
+      end
+      
+      def retrieve(work_type)
+        queue = @queues[work_type]
+        queue.pop if queue
+      end
+      
+      def connect; true; end
+      def close; true; end
+    end
+  end
+end

data/test/discovery_test.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "discovery" do
+  specify "should discover the Util workling, since it subclasses Workling::Base and is on the configured Workling load path." do
+    discovered = Workling::Discovery.discovered
+    discovered.map(&:to_s).should.include "Util"
+  end
+  
+  specify "should not discover non-worker classes" do
+    discovered = Workling::Discovery.discovered
+    discovered.all? { |clazz| clazz.superclass == Workling::Base }.should.blaming("some discovered classes were not workers").equal true
+  end
+end

data/test/invoker_basic_poller_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "the invoker 'basic poller'" do
+  setup do
+    routing = Workling::Routing::ClassAndMethodRouting.new
+    @client = Workling::Clients::MemoryQueueClient.new
+    @client.connect
+    @invoker = Workling::Remote::Invokers::BasicPoller.new(routing, @client.class)
+  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)
+    client.expects(:close).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/invoker_eventmachine_subscription_test.rb

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,9 @@
+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

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

data/test/mocks/rude_queue.rb

@@ -0,0 +1,9 @@
+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

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

data/test/not_remote_runner_test.rb

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,14 @@
+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