batch_api2 0.3.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) { double("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
+    allow(::Rails.application.routes).to receive(:recognize_path).and_return(path_params)
+  end
+
+  describe "#initialize" do
+    it "merges in the Rails path params" do
+      expect(::Rails.application.routes).to receive(:recognize_path).with(
+        op_params["url"],
+        op_params
+      ).and_return(path_params)
+
+      expect(operation.params).to include(path_params)
+    end
+
+    it "doesn't change the params if the path isn't recognized" do
+      allow(::Rails.application.routes).to receive(:recognize_path).and_raise(StandardError)
+      expect(operation.params).to eq(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"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(mixed_params)
+    end
+
+    it "updates the ActionDispatch request params" do
+      key = "action_dispatch.request.request_parameters"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(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) { double("app", call: double) }
+  let(:executor) { BatchApi::Processor::Executor.new(app) }
+  let(:result) { double("result") }
+  let(:op) { double("operation", execute: result) }
+  let(:env) { {op: op} }
+
+  describe "#call" do
+    it "executes the operation" do
+      expect(op).to receive(:execute)
+      executor.call(env)
+    end
+
+    it "returns the result" do
+      expect(executor.call(env)).to eq(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) { double("app", call: double) }
+  let(:sequential) { BatchApi::Processor::Sequential.new(app) }
+
+  describe "#call" do
+    let(:call_results) { 3.times.collect {|i| double("called #{i}") } }
+    let(:env) { {
+      ops: 3.times.collect {|i| double("op #{i}") }
+    } }
+    let(:op_middleware) { double("middleware", call: {}) }
+
+    before :each do
+      allow(BatchApi::InternalMiddleware).
+        to receive(:operation_stack).and_return(op_middleware)
+      allow(op_middleware).to receive(:call).and_return(*call_results)
+    end
+
+    it "creates an operation middleware stack and calls it for each op" do
+      env[:ops].each {|op|
+        expect(op_middleware).to receive(:call).
+          with(hash_including(op: op)).ordered
+      }
+      sequential.call(env)
+    end
+
+    it "includes the rest of the env in the calls" do
+      expect(op_middleware).to receive(:call).
+        with(hash_including(env)).exactly(3).times
+      sequential.call(env)
+    end
+
+    it "returns the results of the calls" do
+      expect(sequential.call(env)).to eq(call_results)
+    end
+  end
+end

data/spec/lib/processor_spec.rb

@@ -0,0 +1,136 @@
+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|
+      allow(r).to receive(:params).and_return({}.merge("ops" => ops).merge(options))
+    end
+  }
+  let(:app) { double("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 = double("op class")
+      allow(BatchApi::Processor).to receive(:operation_klass).and_return(klass)
+      operation_objects = 3.times.collect { double("operation object") }
+      operation_params = 3.times.collect do |i|
+        double("raw operation").tap do |o|
+          expect(klass).to receive(:new)
+            .with(o, env, app).and_return(operation_objects[i])
+        end
+      end
+
+      request.params["ops"] = operation_params
+      expect(BatchApi::Processor.new(request, app).ops).to eq(operation_objects)
+    end
+
+    it "makes the options available" do
+      expect(BatchApi::Processor.new(request, app).options).to eq(options)
+    end
+
+    it "makes the app available" do
+      expect(BatchApi::Processor.new(request, app).app).to eq(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
+      expect(processor.strategy).to eq(BatchApi::Processor::Sequential)
+    end
+  end
+
+  describe "#execute!" do
+    let(:result) { double("result") }
+    let(:stack) { double("stack", call: result) }
+    let(:middleware_env) { {
+      ops: processor.ops, # the processed Operation objects
+      rack_env: env,
+      rack_app: app,
+      options: options
+    } }
+
+    before :each do
+      allow(BatchApi::InternalMiddleware).to receive(:batch_stack).and_return(stack)
+    end
+
+    it "calls an internal middleware stacks with the appropriate data" do
+      expect(stack).to receive(:call).with(middleware_env)
+      processor.execute!
+    end
+
+    it "returns the formatted result of the strategy" do
+      allow(stack).to receive(:call).and_return(stubby = double)
+      expect(processor.execute!["results"]).to eq(stubby)
+    end
+  end
+
+  describe ".operation_klass" do
+    it "returns BatchApi::Operation::Rack if !Rails" do
+      allow(BatchApi).to receive(:rails?).and_return(false)
+      expect(BatchApi::Processor.operation_klass).to eq(
+        BatchApi::Operation::Rack
+      )
+    end
+
+    it "returns BatchApi::Operation::Rails if Rails" do
+      allow(BatchApi).to receive(:rails?).and_return(true)
+      expect(BatchApi::Processor.operation_klass).to eq(
+        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(double("app")) do |conf|
+        conf.limit = limit
+      end
+      expect(BatchApi.config.limit).to eq(limit)
+    end
+  end
+
+  describe "#call" do
+    let(:endpoint) { "/foo/bar" }
+    let(:verb) { "run" }
+    let(:app) { double("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) { double("processor", :execute! => result) }
+
+      before :each do
+        allow(BatchApi::Processor).to receive(:new).and_return(processor)
+      end
+
+      it "processes the batch request" do
+        allow(Rack::Request).to receive(:new).with(env).and_return(request)
+        expect(BatchApi::Processor).to 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)
+          expect(output[2]).to eq([MultiJson.dump(result)])
+        end
+
+        it "returns a 200" do
+          expect(middleware.call(env)[0]).to eq(200)
+        end
+
+        it "sets the content type" do
+          expect(middleware.call(env)[1]).to include("Content-Type" => "application/json")
+        end
+      end
+
+      context "for BatchApi errors" do
+        it "returns a rendered ErrorWrapper" do
+          err, result = StandardError.new, double
+          error = double("error object", render: result)
+          allow(BatchApi::Processor).to receive(:new).and_raise(err)
+          expect(BatchApi::ErrorWrapper).to receive(:new).with(err).and_return(
+            error
+          )
+          expect(middleware.call(env)).to eq(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 = double("output")
+        expect(app).to 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
+      expect(response).to respond_to(local_attr)
+    end
+  end
+
+  describe "#initialize" do
+    it "sets status to the HTTP status code" do
+      expect(response.status).to eq(raw_response.first)
+    end
+
+    it "sets body to the HTTP body turned into a string" do
+      expect(response.body).to eq(raw_response[2].join)
+    end
+
+    it "sets headers to the HTTP headers" do
+      expect(response.headers).to eq(raw_response[1])
+    end
+  end
+
+  describe "#as_json" do
+    it "creates the expected hash" do
+      expect(response.as_json).to eq({
+        body: response.body,
+        status: response.status,
+        headers: response.headers
+      })
+    end
+
+    it "accepts options" do
+      expect(response.as_json(foo: :bar)).not_to be_nil
+    end
+
+    it "leaves out items that are blank" do
+      response.status = response.body = nil
+      expect(response.as_json).to eq({headers: raw_response[1]})
+    end
+
+    it "includes items that are false" do
+      response.body = false
+      expect(response.as_json[:body]).to eq(false)
+    end
+  end
+end