qwirk 0.0.1

data/test/dummy/public/javascripts/rails.js

@@ -0,0 +1,191 @@
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
+  function handleRemote(element) {
+    var method, url, params;
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      params = element.serialize();
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function handleMethod(element) {
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    element.parentNode.insert(form);
+
+    if (method !== 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.insert(field);
+    }
+
+    if (csrf_param) {
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
+    }
+
+    form.submit();
+  }
+
+
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
+
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
+  });
+
+  document.on("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
+  });
+
+  Ajax.Responders.register({
+    onCreate: function(request) {
+      var csrf_meta_tag = $$('meta[name=csrf-token]')[0];
+
+      if (csrf_meta_tag) {
+        var header = 'X-CSRF-Token',
+            token = csrf_meta_tag.readAttribute('content');
+
+        if (!request.options.requestHeaders) {
+          request.options.requestHeaders = {};
+        }
+        request.options.requestHeaders[header] = token;
+      }
+    }
+  });
+})();

data/test/dummy/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env jruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/test/integration/navigation_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class NavigationTest < ActiveSupport::IntegrationCase
+  test "truth" do
+    assert_kind_of Dummy::Application, Rails.application
+  end
+end

data/test/jms.yml

@@ -0,0 +1,9 @@
+:factory: org.apache.activemq.ActiveMQConnectionFactory
+:broker_url: tcp://localhost:61616
+:log_times: false
+:require_jars:
+  - <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/activemq-all-*.jar")[0] %>
+  - <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/lib/optional/slf4j-log4j*.jar")[0] %>
+  - <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/lib/optional/log4j-*.jar")[0] %>
+#:username: myuser
+#:password: mypassword

data/test/jms_fail_test.rb

@@ -0,0 +1,149 @@
+require 'qwirk'
+require 'shoulda'
+require 'test/unit'
+require 'fileutils'
+require 'erb'
+
+# NOTE: This test requires a running ActiveMQ server
+
+class ExceptionWorker
+  include Qwirk::QueueAdapter::JMS::Worker
+  def perform(obj)
+    puts "#{name} received #{obj} but raising exception"
+    raise 'foobar'
+  end
+
+  def log_backtrace(e)
+  end
+end
+
+class ExceptionRequestWorker
+  include Qwirk::QueueAdapter::JMS::RequestWorker
+
+  def request(obj)
+    puts "#{name} received #{obj} but raising exception"
+    raise 'foobar'
+  end
+
+  def log_backtrace(e)
+  end
+end
+
+# This will read from the queue that ExceptionWorker fails to
+class ExceptionFailWorker
+  include Qwirk::QueueAdapter::JMS::Worker
+
+  @@my_hash = {}
+
+  def self.my_obj(name)
+    @@my_hash[name]
+  end
+
+  def perform(obj)
+    puts "#{name} received #{obj}"
+    @@my_hash[name] = obj
+  end
+end
+
+class JMSFailTest < Test::Unit::TestCase
+
+  def assert_fail_queue(queue_name, fail_queue_name, value, is_fail_queue_expected)
+    # Publish to Exception that will throw exception which will put on ExceptionFail queue
+    publisher = Qwirk::QueueAdapter::JMS::Publisher.new(:queue_name => queue_name, :marshal => :string)
+    puts "Publishing #{value} to #{queue_name}"
+    publisher.publish(value)
+    sleep 1
+    expected_value = (is_fail_queue_expected ? value : nil)
+    assert_equal expected_value, ExceptionFailWorker.my_obj(fail_queue_name)
+  end
+
+  context 'jms' do
+    setup do
+      config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), 'jms.yml'))).result(binding))
+      Qwirk::QueueAdapter::JMS::Connection.init(config)
+    end
+
+    teardown do
+    end
+
+    context "worker with exception" do
+      setup do
+        @manager = Qwirk::Manager.new
+
+        # Should receive message on the fail worker when using with default names
+        @manager.add(ExceptionWorker, 1)
+        @manager.add(ExceptionFailWorker, 1)
+
+        # Should receive message on the fail worker when using specified names
+        name = 'ExceptionNameSpecified'
+        @manager.add(ExceptionWorker, 1, :name => name)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should receive message on the fail worker when using specified names and fail_queue set true
+        name = 'ExceptionFailQueueTrue'
+        @manager.add(ExceptionWorker, 1, :name => name, :fail_queue => true)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names and fail_queue set false
+        name = 'ExceptionFailQueueFalse'
+        @manager.add(ExceptionWorker, 1, :name => name, :fail_queue => false)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names and fail_queue set false
+        name = 'ExceptionFailQueueSpecified'
+        fail_queue = 'MyFailQueue'
+        @manager.add(ExceptionWorker, 1, :name => name, :fail_queue => fail_queue)
+        @manager.add(ExceptionFailWorker, 1, :name => fail_queue)
+
+        # Should NOT receive message on the fail worker
+        name = 'ExceptionRequest'
+        @manager.add(ExceptionRequestWorker, 1)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names
+        name = 'ExceptionRequestNameSpecified'
+        @manager.add(ExceptionRequestWorker, 1, :name => name)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should receive message on the fail worker when using specified names and fail_queue set true
+        name = 'ExceptionRequestFailQueueTrue'
+        @manager.add(ExceptionRequestWorker, 1, :name => name, :fail_queue => true)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names and fail_queue set false
+        name = 'ExceptionRequestFailQueueFalse'
+        @manager.add(ExceptionRequestWorker, 1, :name => name, :fail_queue => false)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names and fail_queue set false
+        name = 'ExceptionRequestFailQueueSpecified'
+        fail_queue = 'MyRequestFailQueue'
+        @manager.add(ExceptionRequestWorker, 1, :name => name, :fail_queue => fail_queue)
+        @manager.add(ExceptionFailWorker, 1, :name => fail_queue)
+
+        sleep 1
+      end
+
+      teardown do
+        if @manager
+          @manager.stop
+          @manager.join
+        end
+      end
+
+      should "write fail messages to a fail queue" do
+        assert_fail_queue('Exception',                          'ExceptionFail',                      'value0', true)
+        assert_fail_queue('ExceptionNameSpecified',             'ExceptionNameSpecifiedFail',         'value1', true)
+        assert_fail_queue('ExceptionFailQueueTrue',             'ExceptionFailQueueTrueFail',         'value2', true)
+        assert_fail_queue('ExceptionFailQueueFalse',            'ExceptionFailQueueFalseFail',        'value3', false)
+        assert_fail_queue('ExceptionFailQueueSpecified',        'MyFailQueue',                        'value4', true)
+
+        assert_fail_queue('ExceptionRequest',                   'ExceptionRequestFail',               'value5', false)
+        assert_fail_queue('ExceptionRequestNameSpecified',      'ExceptionRequestNameSpecifiedFail',  'value6', false)
+        assert_fail_queue('ExceptionRequestFailQueueTrue',      'ExceptionRequestFailQueueTrueFail',  'value7', true)
+        assert_fail_queue('ExceptionRequestFailQueueFalse',     'ExceptionRequestFailQueueFalseFail', 'value8', false)
+        assert_fail_queue('ExceptionRequestFailQueueSpecified', 'MyRequestFailQueue',                 'value9', true)
+      end
+    end
+  end
+end

data/test/jms_requestor_block_test.rb

@@ -0,0 +1,278 @@
+require 'qwirk'
+require 'shoulda'
+require 'test/unit'
+require 'fileutils'
+require 'erb'
+
+# NOTE: This test requires a running ActiveMQ server
+
+class BaseRequestWorker
+  include Qwirk::QueueAdapter::JMS::RequestWorker
+
+  def self.sleep_time=(val)
+    @sleep_time = val
+  end
+
+  def self.sleep_time
+    @sleep_time
+  end
+
+  def self.do_exception=(val)
+    @create_exception = val
+  end
+
+  def self.do_exception
+    @create_exception
+  end
+
+  def request(obj)
+    raise Exception,'my exception' if self.class.do_exception
+    sleep self.class.sleep_time if self.class.sleep_time
+  end
+
+  def log_backtrace(e)
+  end
+end
+
+class CharCountWorker < BaseRequestWorker
+  virtual_topic 'test_string'
+  response :marshal => :bson
+
+  def request(obj)
+    super
+    hash = Hash.new(0)
+    obj.each_char {|c| hash[c] += 1}
+    hash
+  end
+end
+
+class LengthWorker < BaseRequestWorker
+  virtual_topic 'test_string'
+  response :marshal => :ruby
+
+  def request(obj)
+    super
+    obj.length
+  end
+end
+
+class ReverseWorker < BaseRequestWorker
+  virtual_topic 'test_string'
+  response :marshal => :string
+
+  def request(obj)
+    super
+    obj.reverse
+  end
+end
+
+class TripleWorker < BaseRequestWorker
+  virtual_topic 'test_string'
+  response :marshal => :string
+
+  def request(obj)
+    super
+    obj*3
+  end
+end
+
+class HolderWorker
+  include Qwirk::QueueAdapter::JMS::Worker
+  virtual_topic 'test_string'
+
+  def self.my_obj
+    @@my_obj
+  end
+
+  def perform(obj)
+    @@my_obj = obj
+  end
+end
+
+class JMSRequestorBlockTest < Test::Unit::TestCase
+
+  def assert_response(hash, expected_key, expected_val)
+    assert_equal 1, hash.keys.size
+    actual_val = hash[expected_key]
+    assert_equal expected_val, actual_val
+  end
+
+  def assert_exception(hash, expected_key)
+    assert_equal 1, hash.keys.size
+    e = hash[expected_key]
+
+    assert e.kind_of?(Qwirk::RemoteException)
+  end
+
+  def make_call(publisher, string, timeout)
+    handle = publisher.publish(string)
+    hash_results = {}
+
+    handle.read_response(timeout) do |response|
+      response.on_message 'CharCount' do |val|
+        hash = hash_results[response.name] ||= {}
+        hash[:message] = val
+      end
+      response.on_message 'CharCount2' do |val|
+        hash = hash_results[response.name] ||= {}
+        hash[:message] = val
+      end
+      response.on_message 'Length', 'Length2', 'Reverse', 'Triple' do |val|
+        hash = hash_results[response.name] ||= {}
+        hash[:message] = val
+      end
+      response.on_timeout 'Reverse' do
+        hash = hash_results[response.name] ||= {}
+        hash[:explicit_timeout] = true
+      end
+      response.on_timeout do
+        hash = hash_results[response.name] ||= {}
+        hash[:default_timeout] = true
+      end
+      response.on_remote_exception 'CharCount' do |e|
+        hash = hash_results[response.name] ||= {}
+        hash[:explicit_exception] = e
+      end
+      response.on_remote_exception do |e|
+        hash = hash_results[response.name] ||= {}
+        hash[:default_exception] = e
+      end
+    end
+    puts "results=#{hash_results.inspect}"
+    # 6 request workers
+    assert_equal 6, hash_results.keys.size
+    assert_equal string, HolderWorker.my_obj
+    return hash_results
+  end
+
+  context 'jms request with block' do
+    setup do
+      config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), 'jms.yml'))).result(binding))
+      Qwirk::QueueAdapter::JMS::Connection.init(config)
+    end
+
+    teardown do
+    end
+
+    context "real publishing" do
+      setup do
+        @manager = Qwirk::Manager.new
+
+        @manager.add(CharCountWorker, 1)
+        @manager.add(CharCountWorker, 1, :name => 'CharCount2')
+        @manager.add(LengthWorker,    1)
+        @manager.add(LengthWorker,    1, :name => 'Length2')
+        @manager.add(ReverseWorker,   1)
+        @manager.add(TripleWorker,    1)
+        @manager.add(HolderWorker,    1)
+
+        sleep 1
+      end
+
+      teardown do
+        if @manager
+          @manager.stop
+          @manager.join
+        end
+      end
+
+      should "handle replies" do
+
+        publisher = Qwirk::QueueAdapter::JMS::Publisher.new(:virtual_topic_name => 'test_string', :response_time_to_live => 10000, :marshal => :string)
+        cc_val = {'f' => 1, 'o' => 4, 'b' => 1}
+
+        hash = make_call(publisher, 'fooboo', 2)
+        assert_response(hash['CharCount'],  :message, cc_val)
+        assert_response(hash['CharCount2'], :message, cc_val)
+        assert_response(hash['Length'],     :message, 6)
+        assert_response(hash['Length2'],    :message,  6)
+        assert_response(hash['Reverse'],    :message, 'ooboof')
+        assert_response(hash['Triple'],     :message,  'fooboofooboofooboo')
+
+        CharCountWorker.sleep_time = 3
+        ReverseWorker.sleep_time   = 3
+        hash = make_call(publisher, 'fooboo', 2)
+        assert_response(hash['CharCount'],  :default_timeout,  true)
+        assert_response(hash['CharCount2'], :default_timeout,  true)
+        assert_response(hash['Length'],     :message, 6)
+        assert_response(hash['Length2'],    :message,  6)
+        assert_response(hash['Reverse'],    :explicit_timeout, true)
+        assert_response(hash['Triple'],     :message,  'fooboofooboofooboo')
+        CharCountWorker.sleep_time = nil
+        ReverseWorker.sleep_time   = nil
+
+        CharCountWorker.do_exception = true
+        TripleWorker.do_exception    = true
+        hash = make_call(publisher, 'fooboo', 2)
+        assert_exception(hash['CharCount'],  :explicit_exception)
+        assert_exception(hash['CharCount2'], :default_exception)
+        assert_response(hash['Length'],      :message, 6)
+        assert_response(hash['Length2'],     :message,  6)
+        assert_response(hash['Reverse'],     :message, 'ooboof')
+        assert_exception(hash['Triple'],     :default_exception)
+        CharCountWorker.do_exception = false
+        TripleWorker.do_exception    = false
+
+        sleep 2
+      end
+    end
+
+    context "dummy publishing" do
+      setup do
+        workers = [
+            CharCountWorker.new,
+            CharCountWorker.new(:name => 'CharCount2'),
+            LengthWorker.new,
+            LengthWorker.new(:name => 'Length2'),
+            ReverseWorker.new,
+            TripleWorker.new,
+            HolderWorker.new,
+        ]
+        Qwirk::QueueAdapter::JMS::Publisher.setup_dummy_publishing(workers)
+      end
+
+      teardown do
+        Qwirk::QueueAdapter::JMS::Publisher.clear_dummy_publishing
+      end
+
+      should "handle replies" do
+
+        publisher = Qwirk::QueueAdapter::JMS::Publisher.new(:virtual_topic_name => 'test_string', :response => true, :marshal => :string)
+        cc_val = {'f' => 1, 'o' => 4, 'b' => 1}
+
+        hash = make_call(publisher, 'fooboo', 2)
+        assert_response(hash['CharCount'],  :message, cc_val)
+        assert_response(hash['CharCount2'], :message, cc_val)
+        assert_response(hash['Length'],     :message, 6)
+        assert_response(hash['Length2'],    :message,  6)
+        assert_response(hash['Reverse'],    :message, 'ooboof')
+        assert_response(hash['Triple'],     :message,  'fooboofooboofooboo')
+
+        # Timeouts don't occur when dummy publishing
+        CharCountWorker.sleep_time = 3
+        ReverseWorker.sleep_time   = 3
+        hash = make_call(publisher, 'fooboo', 2)
+        assert_response(hash['CharCount'],  :message, cc_val)
+        assert_response(hash['CharCount2'], :message, cc_val)
+        assert_response(hash['Length'],     :message, 6)
+        assert_response(hash['Length2'],    :message,  6)
+        assert_response(hash['Reverse'],    :message, 'ooboof')
+        assert_response(hash['Triple'],     :message,  'fooboofooboofooboo')
+        CharCountWorker.sleep_time = nil
+        ReverseWorker.sleep_time   = nil
+
+        CharCountWorker.do_exception = true
+        TripleWorker.do_exception    = true
+        hash = make_call(publisher, 'fooboo', 2)
+        assert_exception(hash['CharCount'],  :explicit_exception)
+        assert_exception(hash['CharCount2'], :default_exception)
+        assert_response(hash['Length'],      :message, 6)
+        assert_response(hash['Length2'],     :message,  6)
+        assert_response(hash['Reverse'],     :message, 'ooboof')
+        assert_exception(hash['Triple'],     :default_exception)
+        CharCountWorker.do_exception = false
+        TripleWorker.do_exception    = false
+      end
+    end
+  end
+end