langis 0.1.0

data/spec/langis/middleware_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+# Helper Rackish App to save the environment from the most recent call.
+class LastEnvApp
+  attr_reader :env
+  def initialize
+    @env = {}
+  end
+  def call(env)
+    @env = env
+  end
+end
+
+describe 'EnvFieldTransform' do
+  it 'should call to_json on a default Langis::MESSAGE_KEY header field' do
+    to_json_value = 'some random json value'
+    call_env = {
+      Langis::MESSAGE_KEY => to_json_value
+    }
+    message_mock = mock 'message'
+    message_mock.should_receive(:to_json).and_return(to_json_value)
+    env = {
+      Langis::MESSAGE_KEY => message_mock
+    }
+    app_mock = mock 'app'
+    app_mock.should_receive(:call).with(call_env)
+    @middleware = Langis::Middleware::EnvFieldTransform.new app_mock
+    @middleware.call(env)
+  end
+
+  it 'should call to_json on a "custom" header field' do
+    fieldname = "custom_field"
+    to_json_value = 'some random json value'
+    call_env = {
+      fieldname => to_json_value
+    }
+    message_mock = mock 'message'
+    message_mock.should_receive(:to_json).and_return(to_json_value)
+    env = {
+      fieldname => message_mock
+    }
+    app_mock = mock 'app'
+    app_mock.should_receive(:call).with(call_env)
+    @middleware = Langis::Middleware::EnvFieldTransform.new(
+      app_mock,
+      :key => fieldname)
+    @middleware.call(env)
+  end
+
+  it 'should call to_json on a "custom" header field with args' do
+    fieldname = "custom_field"
+    to_json_value = 'some random json value'
+    to_args = [1, 2, 3, 4, 5]
+    call_env = {
+      fieldname => to_json_value
+    }
+    message_mock = mock 'message'
+    message_mock.should_receive(:to_json).
+      with(*to_args).
+      and_return(to_json_value)
+    env = {
+      fieldname => message_mock
+    }
+    app_mock = mock 'app'
+    app_mock.should_receive(:call).with(call_env)
+    @middleware = Langis::Middleware::EnvFieldTransform.new(
+      app_mock,
+      :to_args => to_args,
+      :key => fieldname)
+    @middleware.call(env)
+  end
+
+  it 'should call "custom_to_method" on a "custom" header field' do
+    fieldname = "custom_field"
+    to_value = 'some random value'
+    call_env = {
+      fieldname => to_value
+    }
+    message_mock = mock 'message'
+    message_mock.should_receive(:custom_to_method).and_return(to_value)
+    env = {
+      fieldname => message_mock
+    }
+    app_mock = mock 'app'
+    app_mock.should_receive(:call).with(call_env)
+    @middleware = Langis::Middleware::EnvFieldTransform.new(
+      app_mock,
+      :to_method => :custom_to_method,
+      :key => fieldname)
+    @middleware.call(env)
+  end
+end
+
+describe 'Parameterizer' do
+  it 'should form an empty list' do
+    app = LastEnvApp.new
+    middleware = Langis::Middleware::Parameterizer.new app
+    middleware.call {}
+    app.env[Langis::MESSAGE_KEY].should eql []
+  end
+
+  it 'should form a static list' do
+    app = LastEnvApp.new
+    middleware = Langis::Middleware::Parameterizer.new app, '1', '2', '3'
+    middleware.call {}
+    app.env[Langis::MESSAGE_KEY].should eql ['1', '2', '3']
+  end
+
+  it 'should execute callables to form parameters using env values' do
+    app = LastEnvApp.new
+    middleware = Langis::Middleware::Parameterizer.new app,
+      '1',
+      lambda { |env|
+        env['input2']
+      },
+      lambda { |env|
+        env['input3']
+      },
+      '4'
+    middleware.call 'input2' => '2', 'input3' => '3'
+    app.env[Langis::MESSAGE_KEY].should eql ['1', '2', '3', '4']
+  end
+
+  it 'should save to an alternate key' do
+    app = LastEnvApp.new
+    middleware = Langis::Middleware::Parameterizer.new app,
+      '1',
+      lambda { |env|
+        env['input2']
+      },
+      '3',
+      :env_key => 'A'
+    middleware.call 'input2' => '2'
+    app.env['A'].should eql ['1', '2', '3']
+  end
+end
+
+describe 'MessageTypeFilter' do
+  it 'should filter an unlisted type' do
+    message_type_1 = 'MyMessageType1'
+    message_type_2 = 'MyMessageType2'
+    message_type_3 = 'MyMessageType3'
+    message_type_4 = 'MyMessageType4'
+    env = {
+      Langis::MESSAGE_TYPE_KEY => message_type_1
+    }
+    # Set up a mock that won't receive any calls.
+    app_mock = mock 'app'
+    @middleware = Langis::Middleware::MessageTypeFilter.new(
+      app_mock,
+      message_type_2,
+      message_type_3,
+      message_type_4)
+    @middleware.call(env)
+  end
+
+  it 'should allow a listed type through' do
+    message_type_1 = 'MyMessageType1'
+    message_type_2 = 'MyMessageType2'
+    message_type_3 = 'MyMessageType3'
+    message_type_4 = 'MyMessageType4'
+    env = {
+      Langis::MESSAGE_TYPE_KEY => message_type_3
+    }
+    app_mock = mock 'app'
+    app_mock.should_receive(:call).with(env)
+    @middleware = Langis::Middleware::MessageTypeFilter.new(
+      app_mock,
+      message_type_2,
+      message_type_3,
+      message_type_4)
+    @middleware.call(env)
+  end
+
+  it 'should not let anything through' do
+    message_type_1 = 'MyMessageType1'
+    message_type_2 = 'MyMessageType2'
+    message_type_3 = 'MyMessageType3'
+    env1 = {
+      Langis::MESSAGE_TYPE_KEY => message_type_1
+    }
+    env2 = {
+      Langis::MESSAGE_TYPE_KEY => message_type_1
+    }
+    env3 = {
+      Langis::MESSAGE_TYPE_KEY => message_type_1
+    }
+
+    # Set up a mock that won't receive any calls.
+    app_mock = mock 'app'
+    @middleware = Langis::Middleware::MessageTypeFilter.new app_mock
+    @middleware.call(env1)
+    @middleware.call(env2)
+    @middleware.call(env3)
+  end
+end

data/spec/langis/rackish_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Langis::Rackish::RackishJob do
+  before :all do
+    Langis::Rackish::RackishJob.register_rackish_app('my_app', lambda { |env|
+      [200, {}, ["Hello World, #{env['name']}"]]
+    })
+  end
+
+  it 'should raise an error on an unregistered app' do
+    lambda {
+      Langis::Rackish::RackishJob.perform 'unregistered_app'
+    }.should raise_error(Langis::Rackish::NotFoundError)
+  end
+
+  it 'should properly call a registered app using class method' do
+    result = Langis::Rackish::RackishJob.perform 'my_app', 'name' => 'Langis'
+    result.should eql [200, {}, ["Hello World, Langis"]]
+  end
+
+  it 'should properly call a registered app using instance method' do
+    rackish_job = Langis::Rackish::RackishJob.new 'my_app', 'name' => 'Langis'
+    result = rackish_job.perform
+    result.should eql [200, {}, ["Hello World, Langis"]]
+  end
+
+  it 'should handle a nil env by instance method' do
+    rackish_job = Langis::Rackish::RackishJob.new 'my_app', nil
+    result = rackish_job.perform
+    result.should eql [200, {}, ["Hello World, "]]
+  end
+
+end

data/spec/langis/sinks/delayed_job_sink_spec.rb

@@ -0,0 +1,227 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+include Temping
+
+# We create a plain no-op DelayedJob job class.
+class MyJob < Struct.new(:message)
+  def perform
+    nil
+  end
+end
+
+# A helper class to test transforms
+class Transformable
+  def initialize(message, args)
+    @message = message
+    @args = args
+  end
+
+  def transformer(*args)
+    raise 'Transform Arguments mismatch' unless @args == args
+    return @message
+  end
+end
+
+describe 'DelayedJobSink' do
+  before :all do
+    # We have to set up the Delayed::Job constant for this test
+    Delayed::Worker.backend = :active_record
+
+    create_model :delayed_jobs do
+      with_columns do |table|
+        table.integer  :priority, :default => 0
+        table.integer  :attempts, :default => 0
+        table.text     :handler
+        table.string   :last_error
+        table.datetime :run_at
+        table.datetime :locked_at
+        table.datetime :failed_at
+        table.string   :locked_by
+        table.timestamps
+      end
+    end
+  end
+
+  after :each do
+    DelayedJob.all.each do |job|
+      job.delete
+    end
+  end
+
+  it 'should create a delayed job' do
+    my_message = 'Hello World'
+    env = {
+      Langis::MESSAGE_KEY => my_message
+    }
+    sink = Langis::Sinks.delayed_job(MyJob)
+    sink.call(env)
+    delayed_jobs = DelayedJob.all
+    delayed_jobs.size.should eql 1
+    delayed_job = delayed_jobs[0]
+    delayed_job.priority.should eql 0
+    delayed_job.run_at.should_not be_nil
+    my_job = YAML::load delayed_job.handler
+    my_job.message.should eql my_message
+  end
+
+  it 'should create a delayed job with alternate priority' do
+    my_priority = 10239
+    my_message = 'Hello World'
+    env = {
+      Langis::MESSAGE_KEY => my_message
+    }
+    sink = Langis::Sinks.delayed_job(MyJob, :priority => my_priority)
+    sink.call(env)
+    delayed_jobs = DelayedJob.all
+    delayed_jobs.size.should eql 1
+    delayed_job = delayed_jobs[0]
+    delayed_job.priority.should eql my_priority
+    delayed_job.run_at.should_not be_nil
+    my_job = YAML::load delayed_job.handler
+    my_job.message.should eql my_message
+  end
+
+  it 'should create a delayed job with alternate run_at' do
+    my_run_at = Time.now
+    my_message = 'Hello World'
+    env = {
+      Langis::MESSAGE_KEY => my_message
+    }
+    sink = Langis::Sinks.delayed_job(MyJob, :run_at => my_run_at)
+    sink.call(env)
+    delayed_jobs = DelayedJob.all
+    delayed_jobs.size.should eql 1
+    delayed_job = delayed_jobs[0]
+    delayed_job.priority.should eql 0
+    delayed_job.run_at.to_s.should eql my_run_at.to_s
+    my_job = YAML::load delayed_job.handler
+    my_job.message.should eql my_message
+  end
+
+  it 'should create a delayed job with message from alternate key' do
+    my_message = 'Hello World'
+    my_alternate_key = 'MyAlternateKey'
+    env = {
+      my_alternate_key => my_message
+    }
+    sink = Langis::Sinks.delayed_job(MyJob, :env_key => my_alternate_key)
+    sink.call(env)
+    delayed_jobs = DelayedJob.all
+    delayed_jobs.size.should eql 1
+    delayed_job = delayed_jobs[0]
+    delayed_job.priority.should eql 0
+    delayed_job.run_at.should_not be_nil
+    my_job = YAML::load delayed_job.handler
+    my_job.message.should eql my_message
+  end
+
+  it 'should create a delayed job with a message transform' do
+    transform_message = "Hello Transformed World"
+    transform_arguments = [1,2,3,4]
+    my_message = Transformable.new(
+      transform_message,
+      transform_arguments)
+    env = {
+      Langis::MESSAGE_KEY => my_message
+    }
+    sink = Langis::Sinks.delayed_job(MyJob,
+      :transform => :transformer,
+      :transform_args => transform_arguments)
+    sink.call(env)
+    delayed_jobs = DelayedJob.all
+    delayed_jobs.size.should eql 1
+    delayed_job = delayed_jobs[0]
+    delayed_job.priority.should eql 0
+    delayed_job.run_at.should_not be_nil
+    my_job = YAML::load delayed_job.handler
+    my_job.message.should eql transform_message
+  end
+
+  it 'should create a delayed job with a message transform, with nil args' do
+    transform_message = "Hello Transformed World"
+    transform_arguments = []
+    my_message = Transformable.new(
+      transform_message,
+      transform_arguments)
+    env = {
+      Langis::MESSAGE_KEY => my_message
+    }
+    sink = Langis::Sinks.delayed_job(MyJob,
+      :transform => :transformer,
+      :transform_args => nil)
+    sink.call(env)
+    delayed_jobs = DelayedJob.all
+    delayed_jobs.size.should eql 1
+    delayed_job = delayed_jobs[0]
+    delayed_job.priority.should eql 0
+    delayed_job.run_at.should_not be_nil
+    my_job = YAML::load delayed_job.handler
+    my_job.message.should eql transform_message
+  end
+
+  it 'should create a delayed job with a message transform, without args' do
+    transform_message = "Hello Transformed World"
+    transform_arguments = []
+    my_message = Transformable.new(
+      transform_message,
+      transform_arguments)
+    env = {
+      Langis::MESSAGE_KEY => my_message
+    }
+    sink = Langis::Sinks.delayed_job(MyJob,
+      :transform => :transformer)
+    sink.call(env)
+    delayed_jobs = DelayedJob.all
+    delayed_jobs.size.should eql 1
+    delayed_job = delayed_jobs[0]
+    delayed_job.priority.should eql 0
+    delayed_job.run_at.should_not be_nil
+    my_job = YAML::load delayed_job.handler
+    my_job.message.should eql transform_message
+  end
+
+  it 'should create a delayed job with a message transform, non Array arg' do
+    transform_message = "Hello Transformed World"
+    one_arg = "ITSY BITSY ONE"
+    transform_arguments = [one_arg]
+    my_message = Transformable.new(
+      transform_message,
+      transform_arguments)
+    env = {
+      Langis::MESSAGE_KEY => my_message
+    }
+    sink = Langis::Sinks.delayed_job(MyJob,
+      :transform => :transformer,
+      :transform_args => one_arg)
+    sink.call(env)
+    delayed_jobs = DelayedJob.all
+    delayed_jobs.size.should eql 1
+    delayed_job = delayed_jobs[0]
+    delayed_job.priority.should eql 0
+    delayed_job.run_at.should_not be_nil
+    my_job = YAML::load delayed_job.handler
+    my_job.message.should eql transform_message
+  end
+
+  it 'should create a delayed job with all options changed' do
+    my_message = 'Hello World'
+    my_priority = 10239
+    my_alternate_key = 'MyAlternateKey'
+    my_run_at = Time.now
+    env = {
+      my_alternate_key => my_message
+    }
+    sink = Langis::Sinks.delayed_job(MyJob,
+      :env_key => my_alternate_key,
+      :priority => my_priority,
+      :run_at => my_run_at)
+    sink.call(env)
+    delayed_jobs = DelayedJob.all
+    delayed_jobs.size.should eql 1
+    delayed_job = delayed_jobs[0]
+    delayed_job.priority.should eql my_priority
+    delayed_job.run_at.to_s.should eql my_run_at.to_s
+    my_job = YAML::load delayed_job.handler
+    my_job.message.should eql my_message
+  end
+end