adavidev_batch_api 0.2.1.pre.2

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,240 @@
+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 method to get if not provided" do
+      op = BatchApi::Operation::Rack.new(op_params.except("method"), env, app)
+      op.method.should == "get"
+    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 URL is missing" do
+      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)
+    end
+  end
+
+  describe "#process_env" do
+    let(:processed_env) { operation.tap {|o| o.process_env}.env }
+
+    before { BatchApi.config.stub(endpoint: '/api/batch') }
+
+    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 == "http://localhost:3000#{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/api/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"=>"/api/batch",
+      "ORIGINAL_FULLPATH"=>"/api/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

data/spec/lib/operation/rails_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'batch_api/operation'
+
+describe BatchApi::Operation::Rails 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::Rails.new(op_params, env, app) }
+  let(:app) { stub("application", call: [200, {}, ["foo"]]) }
+  let(:path_params) { {controller: "batch_api/batch", action: "batch"} }
+  let(:mixed_params) { op_params["params"].merge(path_params) }
+
+  before :each do
+    ::Rails.application.routes.stub(:recognize_path).and_return(path_params)
+  end
+
+  describe "#initialize" do
+    it "merges in the Rails path params" do
+      ::Rails.application.routes.should_receive(:recognize_path).with(
+        op_params["url"],
+        op_params
+      ).and_return(path_params)
+
+      operation.params.should include(path_params)
+    end
+
+    it "doesn't change the params if the path isn't recognized" do
+      ::Rails.application.routes.stub(:recognize_path).and_raise(StandardError)
+      operation.params.should == op_params["params"]
+    end
+  end
+
+  describe "#process_env" do
+    let(:processed_env) { operation.tap {|o| o.process_env}.env }
+
+    it "updates the ActionDispatch params" do
+      key = "action_dispatch.request.parameters"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == mixed_params
+    end
+
+    it "updates the ActionDispatch request params" do
+      key = "action_dispatch.request.request_parameters"
+      processed_env[key].should_not == env[key]
+      processed_env[key].should == mixed_params
+    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",
+      "action_dispatch.routes"=>Rails.application.routes,
+      "action_dispatch.parameter_filter"=>[:password],
+      "action_dispatch.secret_token"=>"fc6fbc81b3204410da8389",
+      "action_dispatch.show_exceptions"=>true,
+      "action_dispatch.show_detailed_exceptions"=>true,
+      "action_dispatch.logger"=>Rails.logger,
+      "action_dispatch.backtrace_cleaner"=>nil,
+      "action_dispatch.request_id"=>"2e7c988bea73e13dca4fac059a1bb187",
+      "action_dispatch.remote_ip"=>"127.0.0.1",
+      "action_dispatch.request.content_type"=>"application/x-www-form-urlencoded",
+      "action_dispatch.request.path_parameters"=> {},
+      "rack.request.query_string"=>"",
+      "rack.request.query_hash"=>{}
+    }
+  }
+end

data/spec/lib/processor/executor_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'batch_api/processor/executor'
+
+describe BatchApi::Processor::Executor do
+
+  let(:app) { stub("app", call: stub) }
+  let(:executor) { BatchApi::Processor::Executor.new(app) }
+  let(:result) { stub("result") }
+  let(:op) { stub("operation", execute: result) }
+  let(:env) { {op: op} }
+
+  describe "#call" do
+    it "executes the operation" do
+      op.should_receive(:execute)
+      executor.call(env)
+    end
+
+    it "returns the result" do
+      executor.call(env).should == result
+    end
+  end
+end

data/spec/lib/processor/sequential_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe BatchApi::Processor::Sequential do
+
+  let(:app) { stub("app", call: stub) }
+  let(:sequential) { BatchApi::Processor::Sequential.new(app) }
+
+  describe "#call" do
+    let(:call_results) { 3.times.collect {|i| stub("called #{i}") } }
+    let(:env) { {
+      ops: 3.times.collect {|i| stub("op #{i}") }
+    } }
+    let(:op_middleware) { stub("middleware", call: {}) }
+
+    before :each do
+      BatchApi::InternalMiddleware.
+        stub(:operation_stack).and_return(op_middleware)
+      op_middleware.stub(:call).and_return(*call_results)
+    end
+
+    it "creates an operation middleware stack and calls it for each op" do
+      env[:ops].each {|op|
+        op_middleware.should_receive(:call).
+          with(hash_including(op: op)).ordered
+      }
+      sequential.call(env)
+    end
+
+    it "includes the rest of the env in the calls" do
+      op_middleware.should_receive(:call).
+        with(hash_including(env)).exactly(3).times
+      sequential.call(env)
+    end
+
+    it "returns the results of the calls" do
+      sequential.call(env).should == call_results
+    end
+  end
+end