batch_api 0.1.1 → 0.2.0

data/spec/lib/error_wrapper_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'batch_api/error_wrapper'
+
+describe BatchApi::ErrorWrapper do
+  let(:exception) {
+    StandardError.new(Faker::Lorem.words(3)).tap do |e|
+      e.set_backtrace(Kernel.caller)
+    end
+  }
+
+  let(:error) { BatchApi::ErrorWrapper.new(exception) }
+
+  describe "#body" do
+    it "includes the message in the body" do
+      error.body[:error][:message].should == exception.message
+    end
+
+    it "includes the backtrace if it should be there" do
+      error.stub(:expose_backtrace?).and_return(true)
+      error.body[:error][:backtrace].should == exception.backtrace
+    end
+
+    it "includes the backtrace if it should be there" do
+      error.stub(:expose_backtrace?).and_return(false)
+      error.body[:backtrace].should be_nil
+    end
+  end
+
+  describe "#render" do
+    it "returns the appropriate status" do
+      status = stub
+      error.stub(:status_code).and_return(status)
+      error.render[0].should == status
+    end
+
+    it "returns appropriate content type" do
+      ctype = stub
+      BatchApi::RackMiddleware.stub(:content_type).and_return(ctype)
+      error.render[1].should == ctype
+    end
+
+    it "returns the JSONified body as the 2nd" do
+      error.render[2].should == [MultiJson.dump(error.body)]
+    end
+  end
+
+  describe "#status_code" do
+    it "returns 500 by default" do
+      error.status_code.should == 500
+    end
+
+    it "returns another status code if the error supports that" do
+      err = StandardError.new
+      code = stub
+      err.stub(:status_code).and_return(code)
+      BatchApi::ErrorWrapper.new(err).status_code.should == code
+    end
+  end
+
+  describe ".expose_backtrace?" do
+    it "returns false if Rails.env.production?" do
+      Rails.env.stub(:production?).and_return(true)
+      BatchApi::ErrorWrapper.expose_backtrace?.should be_false
+      Rails.env.stub(:production?).and_return(false)
+      BatchApi::ErrorWrapper.expose_backtrace?.should be_true
+    end
+  end
+end

data/spec/lib/internal_middleware/decode_json_body_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe BatchApi::InternalMiddleware::DecodeJsonBody do
+  let(:app) { stub("app", call: result) }
+  let(:decoder) { BatchApi::InternalMiddleware::DecodeJsonBody.new(app) }
+  let(:env) { stub("env") }
+  let(:json) { {"data" => "is_json", "more" => {"hi" => "there"} } }
+  let(:result) {
+    BatchApi::Response.new([
+      200,
+      {"Content-Type" => "application/json"},
+      [MultiJson.dump(json)]
+    ])
+  }
+
+  describe "#call" do
+    context "for json results" do
+      it "decodes JSON results for application/json responses" do
+        result = decoder.call(env)
+        result.body.should == json
+      end
+
+      it "doesn't change anything else" do
+        result = decoder.call(env)
+        result.status.should == 200
+        result.headers.should == {"Content-Type" => "application/json"}
+      end
+    end
+
+    context "for non-JSON responses" do
+      it "doesn't decode" do
+        result.headers = {"Content-Type" => "text/html"}
+        decoder.call(env).body.should == MultiJson.dump(json)
+      end
+    end
+  end
+end

data/spec/lib/internal_middleware/response_filter_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe BatchApi::InternalMiddleware::ResponseFilter do
+  let(:app) { stub("app", call: result) }
+  let(:surpressor) { BatchApi::InternalMiddleware::ResponseFilter.new(app) }
+  let(:env) { {
+    op: stub("operation", options: {"silent" => true})
+  } }
+
+  let(:result) {
+    BatchApi::Response.new([
+      200,
+      {"Content-Type" => "application/json"},
+      ["{}"]
+    ])
+  }
+
+  describe "#call" do
+    context "for results with silent" do
+      context "for successful (200-299) results" do
+        it "empties the response so its as_json is empty" do
+          surpressor.call(env)
+          result.as_json.should == {}
+        end
+      end
+
+      context "for non-successful responses" do
+        it "doesn't change anything else" do
+          result.status = 301
+          expect {
+            surpressor.call(env)
+          }.not_to change(result, :to_s)
+        end
+      end
+    end
+
+    context "for results without silent" do
+      before :each do
+        env[:op].options[:silent] = nil
+      end
+
+      context "for successful (200-299) results" do
+        it "does nothing" do
+          expect {
+            surpressor.call(env)
+          }.not_to change(result, :to_s)
+        end
+      end
+
+      context "for non-successful responses" do
+        it "doesn't change anything else" do
+          result.status = 301
+          expect {
+            surpressor.call(env)
+          }.not_to change(result, :to_s)
+        end
+      end
+    end
+  end
+end
+

data/spec/lib/internal_middleware_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe BatchApi::InternalMiddleware do
+  class FakeBuilder
+    attr_accessor :middlewares
+
+    def initialize(&block)
+      @middlewares = []
+      instance_eval(&block) if block_given?
+    end
+
+    def use(middleware, *args)
+      @middlewares << [middleware, args]
+    end
+  end
+
+  let(:builder) { FakeBuilder.new }
+
+  it "builds an empty default global middleware" do
+    builder.instance_eval(
+      &BatchApi::InternalMiddleware::DEFAULT_BATCH_MIDDLEWARE
+    )
+    builder.middlewares.should be_empty
+  end
+
+  describe "internal middleware defaults" do
+    before :each do
+      builder.instance_eval(
+        &BatchApi::InternalMiddleware::DEFAULT_OPERATION_MIDDLEWARE
+      )
+    end
+
+    it "builds a per-op middleware with the response silencer" do
+      builder.middlewares[0].should ==
+        [BatchApi::InternalMiddleware::ResponseFilter, []]
+    end
+
+    it "builds a per-op middleware with the JSON decoder" do
+      builder.middlewares[1].should ==
+        [BatchApi::InternalMiddleware::DecodeJsonBody, []]
+    end
+  end
+
+  describe ".batch_stack" do
+    # we can't use stubs inside the procs since they're instance_eval'd
+    let(:global_config) { Proc.new { use "Global" } }
+    let(:strategy) { stub("strategy") }
+    let(:processor) { stub("processor", strategy: strategy) }
+    let(:stack) { BatchApi::InternalMiddleware.batch_stack(processor) }
+
+    before :each do
+      BatchApi.config.stub(:batch_middleware).and_return(global_config)
+      stub_const("Middleware::Builder", FakeBuilder)
+    end
+
+    it "builds the stack with the right number of wares" do
+      stack.middlewares.length.should == 2
+    end
+
+    it "builds a middleware stack starting with the configured global wares" do
+      stack.middlewares[0].first.should == "Global"
+    end
+
+    it "inserts the appropriate strategy from the processor" do
+      stack.middlewares[1].first.should == strategy
+    end
+  end
+
+  describe ".operation_stack" do
+    # we can't use stubs inside the procs since they're instance_eval'd
+    let(:op_config) { Proc.new { use "Op" } }
+    let(:stack) { BatchApi::InternalMiddleware.operation_stack }
+
+    before :each do
+      BatchApi.config.stub(:operation_middleware).and_return(op_config)
+      stub_const("Middleware::Builder", FakeBuilder)
+    end
+
+    it "builds the stack with the right number of wares" do
+      stack.middlewares.length.should == 2
+    end
+
+    it "builds a middleware stack including the configured per-op wares" do
+      stack.middlewares[0].first.should == "Op"
+    end
+
+    it "builds a middleware stack ending with the executor" do
+      stack.middlewares[1].first.should == BatchApi::Processor::Executor
+    end
+  end
+end

data/spec/lib/operation/rack_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+require 'batch_api/operation'
+
+describe BatchApi::Operation::Rack do
+  let(:op_params) { {
+    "method" => "POST",
+    # this matches a route in our dummy application
+    "url" => "/endpoint?foo=baz",
+    "params" => {a: 2},
+    "headers" => {"foo" => "bar"}
+  } }
+
+  # for env, see bottom of file - it's long
+  let(:operation) { BatchApi::Operation::Rack.new(op_params, env, app) }
+  let(:app) { stub("application", call: [200, {}, ["foo"]]) }
+
+  describe "accessors" do
+    [
+      :method, :url, :params, :headers,
+      :env, :app, :result, :options
+    ].each do |a|
+      attr = a
+      it "has an accessor for #{attr}" do
+        value = stub
+        operation.send("#{attr}=", value)
+        operation.send(attr).should == value
+      end
+    end
+  end
+
+  describe "#initialize" do
+    ["method", "url", "params", "headers"].each do |a|
+      attr = a
+      it "extracts the #{attr} information from the operation params" do
+        operation.send(attr).should == op_params[attr]
+      end
+    end
+
+    it "sets options to the op" do
+      operation.options.should == op_params
+    end
+
+    it "defaults params to {} if not provided" do
+      op = BatchApi::Operation::Rack.new(op_params.except("params"), env, app)
+      op.params.should == {}
+    end
+
+    it "defaults headers to {} if not provided" do
+      op = BatchApi::Operation::Rack.new(op_params.except("headers"), env, app)
+      op.headers.should == {}
+    end
+
+    it "does a deep dup of the env" do
+      operation.env.should == env
+
+      flat_env = env.to_a.flatten
+      operation.env.to_a.flatten.each_with_index do |obj, index|
+        # this is a rough test for deep dup -- make sure the objects
+        # that aren't symbols aren't actually the same objects in memory
+        if obj.is_a?(Hash) || obj.is_a?(Array)
+          obj.object_id.should_not == flat_env[index].object_id
+        end
+      end
+    end
+
+    it "raises a MalformedOperationError if method or URL are missing" do
+      no_method = op_params.dup.tap {|o| o.delete("method") }
+      expect {
+        BatchApi::Operation::Rack.new(no_method, env, app)
+      }.to raise_exception(BatchApi::Errors::MalformedOperationError)
+
+      no_url = op_params.dup.tap {|o| o.delete("url") }
+      expect {
+        BatchApi::Operation::Rack.new(no_url, env, app)
+      }.to raise_exception(BatchApi::Errors::MalformedOperationError)
+
+      nothing = op_params.dup.tap {|o| o.delete("url"); o.delete("method") }
+      expect {
+        BatchApi::Operation::Rack.new(nothing, env, app)
+      }.to raise_exception(BatchApi::Errors::MalformedOperationError)
+    end
+  end
+
+  describe "#process_env" do
+    let(:processed_env) { operation.tap {|o| o.process_env}.env }
+
+    it "merges any headers in in the right format" do
+      key = "HTTP_FOO" # as defined above in op_params
+
+      processed_env[key].should_not == env[key]
+      # in this case, it's a batch controller
+      processed_env[key].should == op_params["headers"]["foo"]
+    end
+
+    it "preserves existing headers" do
+      processed_env["HTTP_PREVIOUS_HEADERS"].should == env["HTTP_PREVIOUS_HEADERS"]
+    end
+
+    it "updates the method" do
+      key = "REQUEST_METHOD"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == "POST"
+    end
+
+    it "updates the REQUEST_URI" do
+      key = "REQUEST_URI"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == env["REQUEST_URI"].gsub(/\/batch.*/, op_params["url"])
+    end
+
+    it "updates the REQUEST_PATH with the path component (w/o params)" do
+      key = "REQUEST_PATH"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == op_params["url"].split("?").first
+    end
+
+    it "updates the original fullpath" do
+      key = "ORIGINAL_FULLPATH"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == op_params["url"]
+    end
+
+    it "updates the PATH_INFO" do
+      key = "PATH_INFO"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == op_params["url"]
+    end
+
+    it "updates the rack query string" do
+      key = "rack.request.query_string"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == op_params["url"].split("?").last
+    end
+
+    it "updates the QUERY_STRING" do
+      key = "QUERY_STRING"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == op_params["url"].split("?").last
+    end
+
+    it "updates the form hash" do
+      key = "rack.request.form_hash"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == op_params["params"]
+    end
+
+    context "query_hash" do
+      it "sets it to params for a GET" do
+        operation.method = "get"
+        processed_env = operation.tap {|o| o.process_env}.env
+        key = "rack.request.query_hash"
+        processed_env[key].should_not == env[key]
+        processed_env[key].should == op_params["params"]
+      end
+
+      it "sets it to nil for a POST" do
+        key = "rack.request.query_hash"
+        processed_env[key].should_not == env[key]
+        processed_env[key].should be_nil
+      end
+    end
+  end
+
+  describe "#execute" do
+    context "when it works" do
+      let(:result) { [
+        200,
+        {header: "footer"},
+        stub(body: "{\"data\":2}", cookies: nil)
+      ] }
+      let(:processed_env) { stub }
+
+      before :each do
+        operation.stub(:process_env) { operation.env = processed_env }
+      end
+
+      it "executes the call with the application" do
+        app.should_receive(:call).with(processed_env)
+        operation.execute
+      end
+
+      it "returns a BatchAPI::Response made from the result" do
+        response = stub
+        app.stub(:call).and_return(result)
+        BatchApi::Response.should_receive(:new).with(result).and_return(response)
+        operation.execute.should == response
+      end
+
+      it "returns a BatchApi::Response from an ErrorWrapper for errors" do
+        err = StandardError.new
+        result, rendered, response = stub, stub, stub
+        b_err = stub("batch error", render: rendered)
+
+        # simulate the error
+        app.stub(:call).and_raise(err)
+        # we'll create the BatchError
+        BatchApi::ErrorWrapper.should_receive(:new).with(err).and_return(b_err)
+        # render that as the response
+        BatchApi::Response.should_receive(:new).with(rendered).and_return(response)
+        # and return the response overall
+        operation.execute.should == response
+      end
+    end
+  end
+
+  let(:env) {
+    {
+      "CONTENT_LENGTH"=>"10",
+      "CONTENT_TYPE"=>"application/x-www-form-urlencoded",
+      "GATEWAY_INTERFACE"=>"CGI/1.1",
+      "PATH_INFO"=>"/foo",
+      "QUERY_STRING"=>"",
+      "REMOTE_ADDR"=>"127.0.0.1",
+      "REMOTE_HOST"=>"1035.spotilocal.com",
+      "REQUEST_METHOD"=>"REPORT",
+      "REQUEST_URI"=>"http://localhost:3000/batch",
+      "SCRIPT_NAME"=>"",
+      "SERVER_NAME"=>"localhost",
+      "SERVER_PORT"=>"3000",
+      "SERVER_PROTOCOL"=>"HTTP/1.1",
+      "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/1.9.3/2012-02-16)",
+      "HTTP_USER_AGENT"=>"curl/7.21.4 (universal-apple-darwin11.0) libcurl/7.21.4 OpenSSL/0.9.8r zlib/1.2.5",
+      "HTTP_HOST"=>"localhost:3000",
+      "HTTP_ACCEPT"=>"*/*",
+      "HTTP_PREVIOUS_HEADERS" => "value",
+      "rack.version"=>[1,1],
+      "rack.input"=>StringIO.new("{\"ops\":{}}"),
+      "rack.errors"=>$stderr,
+      "rack.multithread"=>false,
+      "rack.multiprocess"=>false,
+      "rack.run_once"=>false,
+      "rack.url_scheme"=>"http",
+      "HTTP_VERSION"=>"HTTP/1.1",
+      "REQUEST_PATH"=>"/batch",
+      "ORIGINAL_FULLPATH"=>"/batch",
+      "rack.request.form_input"=>StringIO.new("{\"ops\":{}}"),
+      "rack.request.form_hash"=>{"{\"ops\":{}}"=>nil},
+      "rack.request.form_vars"=>"{\"ops\":{}}",
+      "rack.request.query_string"=>"",
+      "rack.request.query_hash"=>{}
+    }
+  }
+end