batch_api 0.1.1 → 0.2.0

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

data/spec/lib/processor_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe BatchApi::Processor do
+
+  let(:ops) { [ {"url" => "/endpoint", "method" => "get"} ] }
+  let(:options) { { "sequential" => true } }
+  let(:env) { {
+    "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"=>"",
+    "rack.input" => StringIO.new,
+    "rack.errors" => StringIO.new,
+    "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",
+    "HTTP_HOST"=>"localhost:3000"
+  } }
+
+  let(:request) {
+    Rack::Request.new(env).tap do |r|
+      r.stub(:params).and_return({}.merge("ops" => ops).merge(options))
+    end
+  }
+  let(:app) { stub("application", call: [200, {}, ["foo"]]) }
+  let(:processor) { BatchApi::Processor.new(request, app) }
+
+  describe "#initialize" do
+    # this may be brittle...consider refactoring?
+    it "turns the ops params into processed operations at #ops" do
+      # simulate receiving several operations
+      klass = stub("op class")
+      BatchApi::Processor.stub(:operation_klass).and_return(klass)
+      operation_objects = 3.times.collect { stub("operation object") }
+      operation_params = 3.times.collect do |i|
+        stub("raw operation").tap do |o|
+          klass.should_receive(:new)
+            .with(o, env, app).and_return(operation_objects[i])
+        end
+      end
+
+      request.params["ops"] = operation_params
+      BatchApi::Processor.new(request, app).ops.should == operation_objects
+    end
+
+    it "makes the options available" do
+      BatchApi::Processor.new(request, app).options.should == options
+    end
+
+    it "makes the app available" do
+      BatchApi::Processor.new(request, app).app.should == app
+    end
+
+    context "error conditions" do
+      it "(currently) throws an error if sequential is not true" do
+        request.params.delete("sequential")
+        expect {
+          BatchApi::Processor.new(request, app)
+        }.to raise_exception(BatchApi::Errors::BadOptionError)
+      end
+
+      it "raise a OperationLimitExceeded error if too many ops provided" do
+        ops = (BatchApi.config.limit + 1).to_i.times.collect {|i| i}
+        request.params["ops"] = ops
+        expect {
+          BatchApi::Processor.new(request, app)
+        }.to raise_exception(BatchApi::Errors::OperationLimitExceeded)
+      end
+
+      it "raises a NoOperationError if operations.blank?" do
+        request.params["ops"] = nil
+        expect {
+          BatchApi::Processor.new(request, app)
+        }.to raise_exception(BatchApi::Errors::NoOperationsError)
+        request.params["ops"] = []
+        expect {
+          BatchApi::Processor.new(request, app)
+        }.to raise_exception(BatchApi::Errors::NoOperationsError)
+      end
+    end
+  end
+
+  describe "#strategy" do
+    it "returns BatchApi::Processor::Sequential" do
+      processor.strategy.should == BatchApi::Processor::Sequential
+    end
+  end
+
+  describe "#execute!" do
+    let(:result) { stub("result") }
+    let(:stack) { stub("stack", call: result) }
+    let(:middleware_env) { {
+      ops: processor.ops, # the processed Operation objects
+      rack_env: env,
+      rack_app: app,
+      options: options
+    } }
+
+    before :each do
+      BatchApi::InternalMiddleware.stub(:batch_stack).and_return(stack)
+    end
+
+    it "calls an internal middleware stacks with the appropriate data" do
+      stack.should_receive(:call).with(middleware_env)
+      processor.execute!
+    end
+
+    it "returns the formatted result of the strategy" do
+      stack.stub(:call).and_return(stubby = stub)
+      processor.execute!["results"].should == stubby
+    end
+  end
+
+  describe ".operation_klass" do
+    it "returns BatchApi::Operation::Rack if !Rails" do
+      BatchApi.stub(:rails?).and_return(false)
+      BatchApi::Processor.operation_klass.should ==
+        BatchApi::Operation::Rack
+    end
+
+    it "returns BatchApi::Operation::Rails if Rails" do
+      BatchApi.stub(:rails?).and_return(true)
+      BatchApi::Processor.operation_klass.should ==
+        BatchApi::Operation::Rails
+    end
+  end
+end

data/spec/lib/rack_middleware_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe BatchApi::RackMiddleware do
+  describe "#initialize" do
+    it "allows access to the BatchApi configuration" do
+      limit = rand * 100
+      middleware = BatchApi::RackMiddleware.new(stub("app")) do |conf|
+        conf.limit = limit
+      end
+      BatchApi.config.limit.should == limit
+    end
+  end
+
+  describe "#call" do
+    let(:endpoint) { "/foo/bar" }
+    let(:verb) { "run" }
+    let(:app) { stub("app") }
+
+    let(:middleware) {
+      BatchApi::RackMiddleware.new(app) do |conf|
+        conf.endpoint = endpoint
+        conf.verb = verb
+      end
+    }
+
+    context "if it's a batch call" do
+      let(:env) { {
+        "PATH_INFO" => endpoint,
+        "REQUEST_METHOD" => verb.upcase,
+        # other stuff
+        "CONTENT_TYPE"=>"application/x-www-form-urlencoded",
+        "GATEWAY_INTERFACE"=>"CGI/1.1",
+        "QUERY_STRING"=>"",
+        "REMOTE_ADDR"=>"127.0.0.1",
+        "REMOTE_HOST"=>"1035.spotilocal.com",
+        "REQUEST_URI"=>"http://localhost:3000/batch",
+        "SCRIPT_NAME"=>"",
+        "rack.input" => StringIO.new,
+        "rack.errors" => StringIO.new,
+        "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"
+      } }
+
+      let(:request) { Rack::Request.new(env) }
+      let(:result) { {a: 2, b: {c: 3}} }
+      let(:processor) { stub("processor", :execute! => result) }
+
+      before :each do
+        BatchApi::Processor.stub(:new).and_return(processor)
+      end
+
+      it "processes the batch request" do
+        Rack::Request.stub(:new).with(env).and_return(request)
+        BatchApi::Processor.should_receive(:new).with(request, app).and_return(processor)
+        middleware.call(env)
+      end
+
+      context "for a successful set of calls" do
+        it "returns the JSON-encoded result as the body" do
+          output = middleware.call(env)
+          output[2].should == [MultiJson.dump(result)]
+        end
+
+        it "returns a 200" do
+          middleware.call(env)[0].should == 200
+        end
+
+        it "sets the content type" do
+          middleware.call(env)[1].should include("Content-Type" => "application/json")
+        end
+      end
+
+      context "for BatchApi errors" do
+        it "returns a rendered ErrorWrapper" do
+          err, result = StandardError.new, stub
+          error = stub("error object", render: result)
+          BatchApi::Processor.stub(:new).and_raise(err)
+          BatchApi::ErrorWrapper.should_receive(:new).with(err).and_return(
+            error
+          )
+          middleware.call(env).should == result
+        end
+      end
+    end
+
+    context "if it's not a batch request" do
+      let(:env) { {
+        "PATH_INFO" => "/not/batch",
+        "REQUEST_METHOD" => verb.upcase
+      } }
+
+      it "just calls the app onward and returns the result" do
+        output = stub("output")
+        app.should_receive(:call).with(env).and_return(output)
+        middleware.call(env)
+      end
+    end
+  end
+end

data/spec/lib/response_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'batch_api/response'
+
+describe BatchApi::Response do
+
+  let(:raw_response) { [200, {}, ["ab", "cd", "ef"]] }
+  let(:response) { BatchApi::Response.new(raw_response) }
+
+  [:status, :body, :headers].each do |attr|
+    local_attr = attr
+    it "has an accessor for #{local_attr}" do
+      response.should respond_to(local_attr)
+    end
+  end
+
+  describe "#initialize" do
+    it "sets status to the HTTP status code" do
+      response.status.should == raw_response.first
+    end
+
+    it "sets body to the HTTP body turned into a string" do
+      response.body.should == raw_response[2].join
+    end
+
+    it "sets headers to the HTTP headers" do
+      response.headers.should == raw_response[1]
+    end
+  end
+
+  describe "#as_json" do
+    it "creates the expected hash" do
+      response.as_json.should == {
+        body: response.body,
+        status: response.status,
+        headers: response.headers
+      }
+    end
+
+    it "accepts options" do
+      response.as_json(foo: :bar).should_not be_nil
+    end
+
+    it "leaves out items that are blank" do
+      response.status = response.body = nil
+      response.as_json.should == {headers: raw_response[1]}
+    end
+
+    it "includes items that are false" do
+      response.body = false
+      response.as_json[:body].should == false
+    end
+  end
+end