RubyGems - batch_api2 - Versions diffs - 0.3.0 - Mend

batch_api2 0.3.0

Files changed (91) hide show

checksums.yaml +7 -0
data/MIT-LICENSE +20 -0
data/Rakefile +30 -0
data/changelog.md +74 -0
data/lib/batch_api.rb +28 -0
data/lib/batch_api/batch_error.rb +41 -0
data/lib/batch_api/configuration.rb +36 -0
data/lib/batch_api/error_wrapper.rb +44 -0
data/lib/batch_api/internal_middleware.rb +87 -0
data/lib/batch_api/internal_middleware/decode_json_body.rb +28 -0
data/lib/batch_api/internal_middleware/response_filter.rb +27 -0
data/lib/batch_api/operation.rb +2 -0
data/lib/batch_api/operation/rack.rb +76 -0
data/lib/batch_api/operation/rails.rb +42 -0
data/lib/batch_api/processor.rb +113 -0
data/lib/batch_api/processor/executor.rb +18 -0
data/lib/batch_api/processor/sequential.rb +29 -0
data/lib/batch_api/rack_middleware.rb +37 -0
data/lib/batch_api/response.rb +38 -0
data/lib/batch_api/utils.rb +17 -0
data/lib/batch_api/version.rb +3 -0
data/lib/tasks/batch_api_tasks.rake +4 -0
data/readme.md +243 -0
data/spec/dummy/Gemfile +1 -0
data/spec/dummy/Gemfile.lock +8 -0
data/spec/dummy/README.rdoc +261 -0
data/spec/dummy/Rakefile +15 -0
data/spec/dummy/app/assets/javascripts/application.js +15 -0
data/spec/dummy/app/assets/javascripts/endpoints.js +2 -0
data/spec/dummy/app/assets/stylesheets/application.css +13 -0
data/spec/dummy/app/assets/stylesheets/endpoints.css +4 -0
data/spec/dummy/app/controllers/application_controller.rb +3 -0
data/spec/dummy/app/controllers/endpoints_controller.rb +36 -0
data/spec/dummy/app/helpers/application_helper.rb +2 -0
data/spec/dummy/app/helpers/endpoints_helper.rb +2 -0
data/spec/dummy/app/views/endpoints/get.html.erb +2 -0
data/spec/dummy/app/views/endpoints/post.html.erb +2 -0
data/spec/dummy/app/views/layouts/application.html.erb +14 -0
data/spec/dummy/bin/bundle +3 -0
data/spec/dummy/bin/rails +4 -0
data/spec/dummy/bin/rake +4 -0
data/spec/dummy/bin/setup +29 -0
data/spec/dummy/config.ru +4 -0
data/spec/dummy/config/application.rb +32 -0
data/spec/dummy/config/boot.rb +3 -0
data/spec/dummy/config/database.yml +25 -0
data/spec/dummy/config/environment.rb +5 -0
data/spec/dummy/config/environments/development.rb +41 -0
data/spec/dummy/config/environments/production.rb +79 -0
data/spec/dummy/config/environments/test.rb +42 -0
data/spec/dummy/config/initializers/assets.rb +11 -0
data/spec/dummy/config/initializers/backtrace_silencers.rb +7 -0
data/spec/dummy/config/initializers/cookies_serializer.rb +3 -0
data/spec/dummy/config/initializers/filter_parameter_logging.rb +4 -0
data/spec/dummy/config/initializers/inflections.rb +16 -0
data/spec/dummy/config/initializers/mime_types.rb +4 -0
data/spec/dummy/config/initializers/secret_token.rb +7 -0
data/spec/dummy/config/initializers/session_store.rb +3 -0
data/spec/dummy/config/initializers/wrap_parameters.rb +14 -0
data/spec/dummy/config/locales/en.yml +23 -0
data/spec/dummy/config/routes.rb +64 -0
data/spec/dummy/config/secrets.yml +22 -0
data/spec/dummy/db/test.sqlite3 +0 -0
data/spec/dummy/public/404.html +26 -0
data/spec/dummy/public/422.html +26 -0
data/spec/dummy/public/500.html +25 -0
data/spec/dummy/public/favicon.ico +0 -0
data/spec/dummy/script/rails +6 -0
data/spec/dummy/test/functional/endpoints_controller_test.rb +14 -0
data/spec/dummy/test/unit/helpers/endpoints_helper_test.rb +4 -0
data/spec/lib/batch_api_spec.rb +20 -0
data/spec/lib/batch_error_spec.rb +23 -0
data/spec/lib/configuration_spec.rb +30 -0
data/spec/lib/error_wrapper_spec.rb +68 -0
data/spec/lib/internal_middleware/decode_json_body_spec.rb +44 -0
data/spec/lib/internal_middleware/response_filter_spec.rb +61 -0
data/spec/lib/internal_middleware_spec.rb +93 -0
data/spec/lib/operation/rack_spec.rb +246 -0
data/spec/lib/operation/rails_spec.rb +100 -0
data/spec/lib/processor/executor_spec.rb +22 -0
data/spec/lib/processor/sequential_spec.rb +39 -0
data/spec/lib/processor_spec.rb +136 -0
data/spec/lib/rack_middleware_spec.rb +103 -0
data/spec/lib/response_spec.rb +53 -0
data/spec/rack-integration/rails_spec.rb +10 -0
data/spec/rack-integration/shared_examples.rb +273 -0
data/spec/rack-integration/sinatra_integration_spec.rb +19 -0
data/spec/spec_helper.rb +42 -0
data/spec/support/sinatra_app.rb +54 -0
data/spec/support/sinatra_xhr.rb +13 -0
metadata +214 -0

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The change you wanted was rejected (422)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/422.html -->
+  <div class="dialog">
+    <h1>The change you wanted was rejected.</h1>
+    <p>Maybe you tried to change something you didn't have access to.</p>
+  </div>
+</body>
+</html>

data/spec/dummy/public/500.html ADDED

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <h1>We're sorry, but something went wrong.</h1>
+  </div>
+</body>
+</html>

data/spec/dummy/public/favicon.ico ADDED

File without changes

data/spec/dummy/script/rails ADDED

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/spec/dummy/test/functional/endpoints_controller_test.rb ADDED

@@ -0,0 +1,14 @@
+require 'test_helper'
+class EndpointsControllerTest < ActionController::TestCase
+  test "should get get" do
+    get :get
+    assert_response :success
+  end
+  test "should get post" do
+    get :post
+    assert_response :success
+  end
+end

data/spec/dummy/test/unit/helpers/endpoints_helper_test.rb ADDED

@@ -0,0 +1,4 @@
+require 'test_helper'
+class EndpointsHelperTest < ActionView::TestCase
+end

data/spec/lib/batch_api_spec.rb ADDED

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'batch_api'
+describe BatchApi do
+  describe ".config" do
+    it "has a reader for config" do
+      expect(BatchApi.config).not_to be_nil
+    end
+    it "provides a default config" do
+      expect(BatchApi.config).to be_a(BatchApi::Configuration)
+    end
+  end
+  describe ".rails?" do
+    it "returns a value we can't test based on whether Rails is defined" do
+      expect(BatchApi.rails?).not_to be_nil
+    end
+  end
+end

data/spec/lib/batch_error_spec.rb ADDED

@@ -0,0 +1,23 @@
+require 'spec_helper'
+describe BatchApi::Errors::BatchError do
+  [
+    BatchApi::Errors::OperationLimitExceeded,
+    BatchApi::Errors::BadOptionError,
+    BatchApi::Errors::NoOperationsError,
+    BatchApi::Errors::MalformedOperationError
+  ].each do |klass|
+    it "provides a #{klass} error based on ArgumentError" do
+      expect(klass.superclass).to eq(ArgumentError)
+    end
+    it "is is also a BatchError" do
+      expect(klass.new).to be_a(BatchApi::Errors::BatchError)
+    end
+    it "has a status code of 422" do
+      expect(klass.new.status_code).to eq(422)
+    end
+  end
+end

data/spec/lib/configuration_spec.rb ADDED

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module BatchApi
+  describe Configuration do
+    let(:config) { Configuration.new }
+    describe "options" do
+      {
+        verb: :post,
+        endpoint: "/batch",
+        limit: 50,
+        batch_middleware: InternalMiddleware::DEFAULT_BATCH_MIDDLEWARE,
+        operation_middleware: InternalMiddleware::DEFAULT_OPERATION_MIDDLEWARE
+      }.each_pair do |option, default|
+        opt, defa = option, default
+        describe "##{opt}" do
+          it "has an accessor for #{opt}" do
+            stubby = double
+            config.send("#{opt}=", stubby)
+            expect(config.send(opt)).to eq(stubby)
+          end
+          it "defaults #{opt} to #{defa.inspect}" do
+            expect(config.send(opt)).to eq(defa)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/error_wrapper_spec.rb ADDED

@@ -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
+      expect(error.body[:error][:message]).to eq(exception.message)
+    end
+    it "includes the backtrace if it should be there" do
+      allow(error).to receive(:expose_backtrace?).and_return(true)
+      expect(error.body[:error][:backtrace]).to eq(exception.backtrace)
+    end
+    it "includes the backtrace if it should be there" do
+      allow(error).to receive(:expose_backtrace?).and_return(false)
+      expect(error.body[:backtrace]).to be_nil
+    end
+  end
+  describe "#render" do
+    it "returns the appropriate status" do
+      status = double
+      allow(error).to receive(:status_code).and_return(status)
+      expect(error.render[0]).to eq(status)
+    end
+    it "returns appropriate content type" do
+      ctype = double
+      allow(BatchApi::RackMiddleware).to receive(:content_type).and_return(ctype)
+      expect(error.render[1]).to eq(ctype)
+    end
+    it "returns the JSONified body as the 2nd" do
+      expect(error.render[2]).to eq([MultiJson.dump(error.body)])
+    end
+  end
+  describe "#status_code" do
+    it "returns 500 by default" do
+      expect(error.status_code).to eq(500)
+    end
+    it "returns another status code if the error supports that" do
+      err = StandardError.new
+      code = double
+      allow(err).to receive(:status_code).and_return(code)
+      expect(BatchApi::ErrorWrapper.new(err).status_code).to eq(code)
+    end
+  end
+  describe ".expose_backtrace?" do
+    it "returns false if Rails.env.production?" do
+      allow(Rails).to receive(:env).and_return(double(test?: false, production?: true, development?: false))
+      expect(BatchApi::ErrorWrapper.expose_backtrace?).to be_falsey
+      allow(Rails.env).to receive(:production?).and_return(false)
+      expect(BatchApi::ErrorWrapper.expose_backtrace?).to be_truthy
+    end
+  end
+end

data/spec/lib/internal_middleware/decode_json_body_spec.rb ADDED

@@ -0,0 +1,44 @@
+require 'spec_helper'
+describe BatchApi::InternalMiddleware::DecodeJsonBody do
+  let(:app) { double("app", call: result) }
+  let(:decoder) { BatchApi::InternalMiddleware::DecodeJsonBody.new(app) }
+  let(:env) { double("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)
+        expect(result.body).to eq(json)
+      end
+      it "doesn't change anything else" do
+        result = decoder.call(env)
+        expect(result.status).to eq(200)
+        expect(result.headers).to eq({"Content-Type" => "application/json"})
+      end
+    end
+    context "for non-JSON responses" do
+      it "doesn't decode" do
+        result.headers = {"Content-Type" => "text/html"}
+        expect(decoder.call(env).body).to eq(MultiJson.dump(json))
+      end
+    end
+    context "for empty responses" do
+      it "doesn't try to parse" do
+        result.body = ""
+        expect(decoder.call(env).body).to eq("")
+      end
+    end
+  end
+end

data/spec/lib/internal_middleware/response_filter_spec.rb ADDED

@@ -0,0 +1,61 @@
+require 'spec_helper'
+describe BatchApi::InternalMiddleware::ResponseFilter do
+  let(:app) { double("app", call: result) }
+  let(:surpressor) { BatchApi::InternalMiddleware::ResponseFilter.new(app) }
+  let(:env) { {
+    op: double("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)
+          expect(result.as_json).to eq({})
+        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 ADDED

@@ -0,0 +1,93 @@
+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
+    )
+    expect(builder.middlewares).to 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
+      expect(builder.middlewares[0]).to eq(
+        [BatchApi::InternalMiddleware::ResponseFilter, []]
+      )
+    end
+    it "builds a per-op middleware with the JSON decoder" do
+      expect(builder.middlewares[1]).to eq(
+        [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) { double("strategy") }
+    let(:processor) { double("processor", strategy: strategy) }
+    let(:stack) { BatchApi::InternalMiddleware.batch_stack(processor) }
+    before :each do
+      allow(BatchApi.config).to receive(:batch_middleware).and_return(global_config)
+      stub_const("Middleware::Builder", FakeBuilder)
+    end
+    it "builds the stack with the right number of wares" do
+      expect(stack.middlewares.length).to eq(2)
+    end
+    it "builds a middleware stack starting with the configured global wares" do
+      expect(stack.middlewares[0].first).to eq("Global")
+    end
+    it "inserts the appropriate strategy from the processor" do
+      expect(stack.middlewares[1].first).to eq(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
+      allow(BatchApi.config).to receive(:operation_middleware).and_return(op_config)
+      stub_const("Middleware::Builder", FakeBuilder)
+    end
+    it "builds the stack with the right number of wares" do
+      expect(stack.middlewares.length).to eq(2)
+    end
+    it "builds a middleware stack including the configured per-op wares" do
+      expect(stack.middlewares[0].first).to eq("Op")
+    end
+    it "builds a middleware stack ending with the executor" do
+      expect(stack.middlewares[1].first).to eq(BatchApi::Processor::Executor)
+    end
+  end
+end

data/spec/lib/operation/rack_spec.rb ADDED

@@ -0,0 +1,246 @@
+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) { double("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 = double
+        operation.send("#{attr}=", value)
+        expect(operation.send(attr)).to eq(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
+        expect(operation.send(attr)).to eq(op_params[attr])
+      end
+    end
+    it "sets options to the op" do
+      expect(operation.options).to eq(op_params)
+    end
+    it "defaults method to get if not provided" do
+      op = BatchApi::Operation::Rack.new(op_params.except("method"), env, app)
+      expect(op.method).to eq("get")
+    end
+    it "defaults params to {} if not provided" do
+      op = BatchApi::Operation::Rack.new(op_params.except("params"), env, app)
+      expect(op.params).to eq({})
+    end
+    it "defaults headers to {} if not provided" do
+      op = BatchApi::Operation::Rack.new(op_params.except("headers"), env, app)
+      expect(op.headers).to eq({})
+    end
+    it "does a deep dup of the env" do
+      expect(operation.env).to eq(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)
+          expect(obj.object_id).not_to eq(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
+      expect(processed_env[key]).not_to eq(env[key])
+      # in this case, it's a batch controller
+      expect(processed_env[key]).to eq(op_params["headers"]["foo"])
+    end
+    it "preserves existing headers" do
+      expect(processed_env["HTTP_PREVIOUS_HEADERS"]).to eq(env["HTTP_PREVIOUS_HEADERS"])
+    end
+    it "updates the method" do
+      key = "REQUEST_METHOD"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq("POST")
+    end
+    it "updates the REQUEST_URI" do
+      key = "REQUEST_URI"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq("http://localhost:3000#{op_params["url"]}")
+    end
+    it "works if REQUEST_URI is blank" do
+      key = "REQUEST_URI"
+      env.delete(key)
+      expect(processed_env[key]).to be_nil
+    end
+    it "updates the REQUEST_PATH with the path component (w/o params)" do
+      key = "REQUEST_PATH"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(op_params["url"].split("?").first)
+    end
+    it "updates the original fullpath" do
+      key = "ORIGINAL_FULLPATH"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(op_params["url"])
+    end
+    it "updates the PATH_INFO" do
+      key = "PATH_INFO"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(op_params["url"])
+    end
+    it "updates the rack query string" do
+      key = "rack.request.query_string"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(op_params["url"].split("?").last)
+    end
+    it "updates the QUERY_STRING" do
+      key = "QUERY_STRING"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(op_params["url"].split("?").last)
+    end
+    it "updates the form hash" do
+      key = "rack.request.form_hash"
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(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"
+        expect(processed_env[key]).not_to eq(env[key])
+        expect(processed_env[key]).to eq(op_params["params"])
+      end
+      it "sets it to nil for a POST" do
+        key = "rack.request.query_hash"
+        expect(processed_env[key]).not_to eq(env[key])
+        expect(processed_env[key]).to be_nil
+      end
+    end
+  end
+  describe "#execute" do
+    context "when it works" do
+      let(:result) { [
+        200,
+        {header: "footer"},
+        double(body: "{\"data\":2}", cookies: nil)
+      ] }
+      let(:processed_env) { double }
+      before :each do
+        allow(operation).to receive(:process_env) { operation.env = processed_env }
+      end
+      it "executes the call with the application" do
+        expect(app).to receive(:call).with(processed_env)
+        operation.execute
+      end
+      it "returns a BatchAPI::Response made from the result" do
+        response = double
+        allow(app).to receive(:call).and_return(result)
+        expect(BatchApi::Response).to receive(:new).with(result).and_return(response)
+        expect(operation.execute).to eq(response)
+      end
+      it "returns a BatchApi::Response from an ErrorWrapper for errors" do
+        err = StandardError.new
+        result, rendered, response = double, double, double
+        b_err = double("batch error", render: rendered)
+        # simulate the error
+        allow(app).to receive(:call).and_raise(err)
+        # we'll create the BatchError
+        expect(BatchApi::ErrorWrapper).to receive(:new).with(err).and_return(b_err)
+        # render that as the response
+        expect(BatchApi::Response).to receive(:new).with(rendered).and_return(response)
+        # and return the response overall
+        expect(operation.execute).to eq(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