RubyGems - batch_api2 - Versions diffs - 0.3.0 - Mend

batch_api2 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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

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

@@ -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