wamp-worker 0.1.0

data/spec/wamp/worker/handler_spec.rb

@@ -0,0 +1,162 @@
+require "spec_helper"
+
+describe Wamp::Worker::Handler do
+  let(:name) { :default }
+  let(:session) { SessionStub.new }
+  let(:proxy) { Wamp::Worker::Proxy::Dispatcher.new(name, session) }
+
+  it "registers the handlers" do
+    config = Wamp::Worker.config
+
+    expect(config.subscriptions.count).to eq(2)
+    expect(config.subscriptions(name).count).to eq(2)
+    expect(config.subscriptions(:other).count).to eq(2)
+
+    expect(config.registrations.count).to eq(16)
+    expect(config.registrations(name).count).to eq(16)
+    expect(config.registrations(:other).count).to eq(2)
+  end
+
+  def setup_handlers
+    Wamp::Worker.subscribe_topics(name, proxy, session)
+    Wamp::Worker.register_procedures(name, proxy, session)
+  end
+
+  it "executes the normal handlers" do
+    setup_handlers
+
+    expect{
+      session.publish("topic", nil, nil)
+
+      session.call("return_error", nil, nil) do |result, error, details|
+        expect(error[:error]).to eq("error")
+      end
+
+      session.call("throw_error", nil, nil) do |result, error, details|
+        expect(error[:error]).to eq("error")
+      end
+
+      session.call("throw_exception", nil, nil) do |result, error, details|
+        expect(error[:error]).to eq("wamp.error.runtime")
+        expect(error[:args][0]).to eq("error")
+      end
+
+      session.call("call_result", [3], nil) do |result, error, details|
+        expect(result[:args][0]).to eq(5)
+      end
+
+      session.call("normal_result", [3], nil) do |result, error, details|
+        expect(result[:args][0]).to eq(6)
+      end
+
+      session.call("nil_result", [3], nil) do |result, error, details|
+        expect(result[:args][0]).to eq(nil)
+      end
+
+      session.call("proxy_result", [3], nil) do |result, error, details|
+        expect(result[:args][0]).to eq(6)
+      end
+    }.to change{ NormalHandler.run_count }.by(9)
+
+  end
+
+  it "executes the background handlers" do
+    setup_handlers
+
+    queue_count = 0
+    queue_params = nil
+
+    allow_any_instance_of(Wamp::Worker::Queue).to receive(:push) do |queue, queue_name, command, params, handle|
+      queue_params = params[:result]
+      queue_count += 1
+      expect(command).to eq(:yield)
+    end
+
+    expect{
+      session.publish("back.topic", nil, nil)
+
+      session.call("back.return_error", nil, nil)
+      expect(queue_params[:error]).to eq("error")
+
+      session.call("back.throw_error", nil, nil)
+      expect(queue_params[:error]).to eq("error")
+
+      session.call("back.throw_exception", nil, nil)
+      expect(queue_params[:error]).to eq("wamp.error.runtime")
+
+      session.call("back.call_result", [3], nil)
+      expect(queue_params[:args][0]).to eq(5)
+
+      session.call("back.normal_result", [3], nil)
+      expect(queue_params[:args][0]).to eq(6)
+
+      session.call("back.nil_result", [3], nil)
+      expect(queue_params[:args][0]).to eq(nil)
+    }.to change{ BackgroundHandler.run_count }.by(7)
+
+    expect(queue_count).to eq(6)
+  end
+
+  context "progress" do
+    before(:each) {
+      setup_handlers
+    }
+
+    it "reports the progress in the foreground" do
+      count = 0
+
+      session.call("progress_result", [3], nil, { receive_progress: true }) do |result, error, details|
+        case count
+        when 0
+          expect(result[:args][0]).to eq(0)
+          expect(details[:progress]).to eq(true)
+        when 1
+          expect(result[:args][0]).to eq(0.5)
+          expect(details[:progress]).to eq(true)
+        when 2
+          expect(result[:args][0]).to eq(1.0)
+          expect(details[:progress]).to eq(true)
+        else
+          expect(result[:args][0]).to eq(7)
+          expect(details[:progress]).not_to eq(true)
+        end
+
+        count += 1
+      end
+
+      expect(count).to eq(4)
+    end
+
+    it "reports the progress in the background" do
+      count = 0
+
+      allow_any_instance_of(Wamp::Worker::Queue).to receive(:push) do |queue, queue_name, command, params, handle|
+        result = params[:result]
+        options = params[:options]
+
+        case count
+        when 0
+          expect(result[:args][0]).to eq(0)
+          expect(options[:progress]).to eq(true)
+        when 1
+          expect(result[:args][0]).to eq(0.5)
+          expect(options[:progress]).to eq(true)
+        when 2
+          expect(result[:args][0]).to eq(1.0)
+          expect(options[:progress]).to eq(true)
+        else
+          expect(result[:args][0]).to eq(7)
+          expect(options[:progress]).not_to eq(true)
+        end
+
+        count += 1
+      end
+
+      session.call("back.progress_result", [3], nil, { receive_progress: true })
+
+      expect(count).to eq(4)
+    end
+  end
+
+end
+

data/spec/wamp/worker/proxy_spec.rb

@@ -0,0 +1,153 @@
+require "spec_helper"
+require "thread"
+
+class RequestorClass
+  include Wamp::Worker::Session.new(method: :temp_session)
+end
+
+describe Wamp::Worker::Proxy do
+  let(:name) { :default }
+  let(:topic) { "topic" }
+  let(:procedure) { "procedure" }
+  let(:session) { SessionStub.new }
+  let(:dispatcher) { described_class::Dispatcher.new(name, session) }
+  let(:requestor) { RequestorClass.new.temp_session }
+
+  before(:each) {
+    Wamp::Worker.subscribe_topics(name, dispatcher, session)
+    Wamp::Worker.register_procedures(name, dispatcher, session)
+  }
+
+  def check_method(times, method, *args)
+    check_result = nil
+    check_error = nil
+
+    # Create a thread to run the dispatcher
+    thread = Thread.new do
+      times.times do
+        descriptor = dispatcher.check_queues
+        dispatcher.process(descriptor)
+      end
+    end
+
+    requestor.send(method, *args) do |result, error, details|
+      check_result = result
+      check_error = error
+    end
+
+    # Wait for the thread to complete
+    thread.join
+
+    yield(check_result, check_error)
+  end
+
+  context "command/response flow" do
+
+    it "executes a call command" do
+      expect {
+        check_method(1, :call, "normal_result", [7]) do |result, error|
+          expect(result[:args][0]).to eq(10)
+          expect(error).to be_nil
+        end
+      }.to change{ NormalHandler.run_count }.by(1)
+    end
+
+    it "executes a call command with invalid procedure" do
+      expect {
+        check_method(1, :call, "invalid_procedure", [7]) do |result, error|
+          expect(result).to be_nil
+          expect(error).to eq({ error: "wamp.no_procedure", args:[], kwargs:{} })
+        end
+      }.to change{ NormalHandler.run_count }.by(0)
+    end
+
+    it "executes a call command with throw error" do
+      expect {
+        check_method(1, :call, "throw_error", [7]) do |result, error|
+          expect(result).to be_nil
+          expect(error).to eq({ error: "error", args:[], kwargs:{} })
+        end
+      }.to change{ NormalHandler.run_count }.by(1)
+    end
+
+    it "executes a publish command w/o acknowledge" do
+      expect {
+        check_method(1, :publish, "topic", [7]) do |result, error|
+          expect(result).to be_nil
+          expect(error).to be_nil
+        end
+      }.to change{ NormalHandler.run_count }.by(1)
+    end
+
+    it "executes a publish command w/ acknowledge" do
+      expect {
+        check_method(1, :publish, "topic", [7], {}, { acknowledge: true }) do |result, error|
+          expect(result).to eq(1234)
+          expect(error).to be_nil
+        end
+      }.to change{ NormalHandler.run_count }.by(1)
+    end
+
+    it "executes a publish command w/ acknowledge and error" do
+      expect {
+        check_method(1, :publish, "invalid_topic", [7], {}, { acknowledge: true }) do |result, error|
+          expect(result).to eq(1234)
+          expect(error).to eq({ error: "wamp.no_subscriber", args:[], kwargs:{} })
+        end
+      }.to change{ NormalHandler.run_count }.by(0)
+    end
+
+    it "errors on unsupported proxy command" do
+      requestor.queue.push requestor.command_req_queue, :bad, {}, "handle"
+
+      descriptor = dispatcher.check_queues
+      dispatcher.process(descriptor)
+
+      descriptor = requestor.queue.pop("handle")
+      expect(descriptor.command).to eq(:bad)
+      expect(descriptor.params[:error][:error]).to eq("wamp.error.runtime")
+      expect(descriptor.params[:error][:args][0]).to eq("unsupported proxy command 'bad'")
+    end
+  end
+
+  context "dispatcher/backgrounder flow" do
+
+    it "executes a 'call' command" do
+      expect {
+        check_method(2, :call, "back.normal_result", [7]) do |result, error|
+          expect(result[:args][0]).to eq(10)
+          expect(error).to be_nil
+        end
+      }.to change{ BackgroundHandler.run_count }.by(1)
+    end
+
+    it "executes a 'call' command with throw error" do
+      expect {
+        check_method(2, :call, "back.throw_error", [7]) do |result, error|
+          expect(result).to be_nil
+          expect(error).to eq({ error: "error", args:[], kwargs:{} })
+        end
+      }.to change{ BackgroundHandler.run_count }.by(1)
+    end
+
+    it "executes a 'publish' command w/o acknowledge" do
+      expect {
+        check_method(1, :publish, "back.topic", [7]) do |result, error|
+          expect(result).to be_nil
+          expect(error).to be_nil
+        end
+      }.to change{ BackgroundHandler.run_count }.by(1)
+    end
+
+    it "executes a 'publish' command w/ acknowledge" do
+      expect {
+        check_method(1, :publish, "back.topic", [7], {}, { acknowledge: true }) do |result, error|
+          expect(result).to eq(1234)
+          expect(error).to be_nil
+        end
+      }.to change{ BackgroundHandler.run_count }.by(1)
+    end
+  end
+
+end
+

data/spec/wamp/worker/queue_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Wamp::Worker::Queue do
+  let(:name) { :default }
+  let(:queue) { described_class.new(name) }
+  let(:queue_name) { "test:command" }
+  let(:handle) { "test:response" }
+  let(:params) { { temp: true } }
+
+  it "general push/pop" do
+    # Push the request
+    queue.push queue_name, :call, params, handle
+
+    # Pop the request
+    descriptor = queue.pop(queue_name, wait: true)
+    expect(descriptor.command).to eq(:call)
+    expect(descriptor.handle).to eq(handle)
+    expect(descriptor.params).to eq(params)
+
+    # Check and make sure the key still exists
+    expect(queue.redis.exists(queue_name)).to eq(true)
+  end
+
+  it "deletes on pop" do
+    expect(queue.redis.exists(queue_name)).to eq(false)
+
+    # Push the request
+    queue.push queue_name, :call, params, handle
+
+    expect(queue.redis.exists(queue_name)).to eq(true)
+
+    # Pop the request
+    descriptor = queue.pop(queue_name, delete: true)
+    expect(descriptor.command).to eq(:call)
+    expect(descriptor.handle).to eq(handle)
+    expect(descriptor.params).to eq(params)
+
+    expect(queue.redis.exists(queue_name)).to eq(false)
+  end
+
+  it "timeout" do
+    # Pop the descriptor
+    descriptor = queue.pop(queue_name, wait: true, timeout: 1)
+
+    # It should be nil
+    expect(descriptor).to eq(nil)
+  end
+
+end

data/spec/wamp/worker/runner_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe Wamp::Worker::Runner do
+  let(:name) { :other }
+  let(:runner) { described_class::Main.new(name) }
+  let(:requestor) { Wamp::Worker.requestor(name) }
+
+  def execute_runner
+
+    # Start the runner
+    runner.start
+
+    # Start it and the event machine on a different thread
+    thread = Thread.new do
+      EM.run {}
+    end
+
+    yield
+
+    # Stop the event machine
+    runner.client.transport_class.stop_event_machine
+    thread.join
+
+    # Stop the runner
+    runner.stop
+
+  end
+
+  it "registers and subscribes" do
+
+    # Check attributes
+    expect(runner.active?).to eq(false)
+    expect(runner.dispatcher.session).to be_nil
+
+    execute_runner do
+
+      # Check attributes
+      expect(runner.active?).to eq(true)
+      expect(runner.dispatcher.session).to be(runner.client.session)
+
+      # Check that some of the handlers work
+      expect{
+        requestor.call("other.call_result", [3], nil) do |result, error, details|
+          expect(result[:args][0]).to eq(5)
+        end
+      }.to change{ NormalHandler.run_count }.by(1)
+
+      expect{
+        requestor.call("back.other.call_result", [4], nil) do |result, error, details|
+          expect(result[:args][0]).to eq(6)
+        end
+      }.to change{ BackgroundHandler.run_count }.by(1)
+
+    end
+
+    # Check attributes
+    expect(runner.active?).to eq(false)
+    expect(runner.dispatcher.session).to be_nil
+  end
+
+  it "synchronizes the UUID between all of the runners" do
+    uuid = runner.dispatcher.uuid
+    expect(runner.queue_monitor.dispatcher.uuid).to eq(uuid)
+  end
+
+  it "increments the ticker" do
+    expect(runner.dispatcher.ticker.get).to eq(0)
+
+    expect {
+      execute_runner do
+        sleep(2.5)
+      end
+    }.to change{ runner.dispatcher.ticker.get }.by(3)
+  end
+
+  context "challenge" do
+    it "errors if challenge is called but no method was passed in" do
+      runner = described_class::Main.new :test, client: ClientStub.new({should_challenge: true})
+
+      # Errors because the callback wasn't defined
+      expect {
+        runner.start
+      }.to raise_error(ArgumentError)
+
+      # Ensure that the runner terminated
+      expect(runner.active?).to eq(false)
+    end
+
+    it "does not error when the challenge is defined" do
+      value = 0
+
+      # Create the runner passing it the challenge method
+      runner = described_class::Main.new :test,
+                                         challenge: -> authmethod, details {value += 1},
+                                         client: ClientStub.new({should_challenge: true})
+
+      # Start the runner
+      runner.start
+
+      # Expect that the challenge method was called
+      expect(value).to eq(1)
+
+      # Stop the runner
+      runner.stop
+    end
+
+  end
+end