batch_api 0.2.1 → 0.3.0

data/spec/lib/batch_api_spec.rb

@@ -4,17 +4,17 @@ require 'batch_api'
 describe BatchApi do
   describe ".config" do
     it "has a reader for config" do
-      BatchApi.config.should_not be_nil
+      expect(BatchApi.config).not_to be_nil
     end
 
     it "provides a default config" do
-      BatchApi.config.should be_a(BatchApi::Configuration)
+      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
-      BatchApi.rails?.should_not be_nil
+      expect(BatchApi.rails?).not_to be_nil
     end
   end
 end

data/spec/lib/batch_error_spec.rb

@@ -9,15 +9,15 @@ describe BatchApi::Errors::BatchError do
     BatchApi::Errors::MalformedOperationError
   ].each do |klass|
     it "provides a #{klass} error based on ArgumentError" do
-      klass.superclass.should == ArgumentError
+      expect(klass.superclass).to eq(ArgumentError)
     end
 
     it "is is also a BatchError" do
-      klass.new.should be_a(BatchApi::Errors::BatchError)
+      expect(klass.new).to be_a(BatchApi::Errors::BatchError)
     end
 
     it "has a status code of 422" do
-      klass.new.status_code.should == 422
+      expect(klass.new.status_code).to eq(422)
     end
   end
 end

data/spec/lib/configuration_spec.rb

@@ -15,13 +15,13 @@ module BatchApi
         opt, defa = option, default
         describe "##{opt}" do
           it "has an accessor for #{opt}" do
-            stubby = stub
+            stubby = double
             config.send("#{opt}=", stubby)
-            config.send(opt).should == stubby
+            expect(config.send(opt)).to eq(stubby)
           end
 
           it "defaults #{opt} to #{defa.inspect}" do
-            config.send(opt).should == defa
+            expect(config.send(opt)).to eq(defa)
           end
         end
       end

data/spec/lib/error_wrapper_spec.rb

@@ -12,57 +12,57 @@ describe BatchApi::ErrorWrapper do
 
   describe "#body" do
     it "includes the message in the body" do
-      error.body[:error][:message].should == exception.message
+      expect(error.body[:error][:message]).to eq(exception.message)
     end
 
     it "includes the backtrace if it should be there" do
-      error.stub(:expose_backtrace?).and_return(true)
-      error.body[:error][:backtrace].should == exception.backtrace
+      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
-      error.stub(:expose_backtrace?).and_return(false)
-      error.body[:backtrace].should be_nil
+      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 = stub
-      error.stub(:status_code).and_return(status)
-      error.render[0].should == status
+      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 = stub
-      BatchApi::RackMiddleware.stub(:content_type).and_return(ctype)
-      error.render[1].should == ctype
+      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
-      error.render[2].should == [MultiJson.dump(error.body)]
+      expect(error.render[2]).to eq([MultiJson.dump(error.body)])
     end
   end
 
   describe "#status_code" do
     it "returns 500 by default" do
-      error.status_code.should == 500
+      expect(error.status_code).to eq(500)
     end
 
     it "returns another status code if the error supports that" do
       err = StandardError.new
-      code = stub
-      err.stub(:status_code).and_return(code)
-      BatchApi::ErrorWrapper.new(err).status_code.should == code
+      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
-      Rails.env.stub(:production?).and_return(true)
-      BatchApi::ErrorWrapper.expose_backtrace?.should be_false
-      Rails.env.stub(:production?).and_return(false)
-      BatchApi::ErrorWrapper.expose_backtrace?.should be_true
+      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

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe BatchApi::InternalMiddleware::DecodeJsonBody do
-  let(:app) { stub("app", call: result) }
+  let(:app) { double("app", call: result) }
   let(:decoder) { BatchApi::InternalMiddleware::DecodeJsonBody.new(app) }
-  let(:env) { stub("env") }
+  let(:env) { double("env") }
   let(:json) { {"data" => "is_json", "more" => {"hi" => "there"} } }
   let(:result) {
     BatchApi::Response.new([
@@ -17,20 +17,27 @@ describe BatchApi::InternalMiddleware::DecodeJsonBody do
     context "for json results" do
       it "decodes JSON results for application/json responses" do
         result = decoder.call(env)
-        result.body.should == json
+        expect(result.body).to eq(json)
       end
 
       it "doesn't change anything else" do
         result = decoder.call(env)
-        result.status.should == 200
-        result.headers.should == {"Content-Type" => "application/json"}
+        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"}
-        decoder.call(env).body.should == MultiJson.dump(json)
+        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

data/spec/lib/internal_middleware/response_filter_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe BatchApi::InternalMiddleware::ResponseFilter do
-  let(:app) { stub("app", call: result) }
+  let(:app) { double("app", call: result) }
   let(:surpressor) { BatchApi::InternalMiddleware::ResponseFilter.new(app) }
   let(:env) { {
-    op: stub("operation", options: {"silent" => true})
+    op: double("operation", options: {"silent" => true})
   } }
 
   let(:result) {
@@ -20,7 +20,7 @@ describe BatchApi::InternalMiddleware::ResponseFilter 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 == {}
+          expect(result.as_json).to eq({})
         end
       end
 

data/spec/lib/internal_middleware_spec.rb

@@ -20,7 +20,7 @@ describe BatchApi::InternalMiddleware do
     builder.instance_eval(
       &BatchApi::InternalMiddleware::DEFAULT_BATCH_MIDDLEWARE
     )
-    builder.middlewares.should be_empty
+    expect(builder.middlewares).to be_empty
   end
 
   describe "internal middleware defaults" do
@@ -31,38 +31,40 @@ describe BatchApi::InternalMiddleware do
     end
 
     it "builds a per-op middleware with the response silencer" do
-      builder.middlewares[0].should ==
+      expect(builder.middlewares[0]).to eq(
         [BatchApi::InternalMiddleware::ResponseFilter, []]
+      )
     end
 
     it "builds a per-op middleware with the JSON decoder" do
-      builder.middlewares[1].should ==
+      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) { stub("strategy") }
-    let(:processor) { stub("processor", strategy: strategy) }
+    let(:strategy) { double("strategy") }
+    let(:processor) { double("processor", strategy: strategy) }
     let(:stack) { BatchApi::InternalMiddleware.batch_stack(processor) }
 
     before :each do
-      BatchApi.config.stub(:batch_middleware).and_return(global_config)
+      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
-      stack.middlewares.length.should == 2
+      expect(stack.middlewares.length).to eq(2)
     end
 
     it "builds a middleware stack starting with the configured global wares" do
-      stack.middlewares[0].first.should == "Global"
+      expect(stack.middlewares[0].first).to eq("Global")
     end
 
     it "inserts the appropriate strategy from the processor" do
-      stack.middlewares[1].first.should == strategy
+      expect(stack.middlewares[1].first).to eq(strategy)
     end
   end
 
@@ -72,20 +74,20 @@ describe BatchApi::InternalMiddleware do
     let(:stack) { BatchApi::InternalMiddleware.operation_stack }
 
     before :each do
-      BatchApi.config.stub(:operation_middleware).and_return(op_config)
+      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
-      stack.middlewares.length.should == 2
+      expect(stack.middlewares.length).to eq(2)
     end
 
     it "builds a middleware stack including the configured per-op wares" do
-      stack.middlewares[0].first.should == "Op"
+      expect(stack.middlewares[0].first).to eq("Op")
     end
 
     it "builds a middleware stack ending with the executor" do
-      stack.middlewares[1].first.should == BatchApi::Processor::Executor
+      expect(stack.middlewares[1].first).to eq(BatchApi::Processor::Executor)
     end
   end
 end

data/spec/lib/operation/rack_spec.rb

@@ -12,7 +12,7 @@ describe BatchApi::Operation::Rack do
 
   # 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"]]) }
+  let(:app) { double("application", call: [200, {}, ["foo"]]) }
 
   describe "accessors" do
     [
@@ -21,9 +21,9 @@ describe BatchApi::Operation::Rack do
     ].each do |a|
       attr = a
       it "has an accessor for #{attr}" do
-        value = stub
+        value = double
         operation.send("#{attr}=", value)
-        operation.send(attr).should == value
+        expect(operation.send(attr)).to eq(value)
       end
     end
   end
@@ -32,38 +32,38 @@ describe BatchApi::Operation::Rack 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]
+        expect(operation.send(attr)).to eq(op_params[attr])
       end
     end
 
     it "sets options to the op" do
-      operation.options.should == op_params
+      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)
-      op.method.should == "get"
+      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)
-      op.params.should == {}
+      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)
-      op.headers.should == {}
+      expect(op.headers).to eq({})
     end
 
     it "does a deep dup of the env" do
-      operation.env.should == env
+      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)
-          obj.object_id.should_not == flat_env[index].object_id
+          expect(obj.object_id).not_to eq(flat_env[index].object_id)
         end
       end
     end
@@ -79,64 +79,72 @@ describe BatchApi::Operation::Rack do
   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]
+      expect(processed_env[key]).not_to eq(env[key])
       # in this case, it's a batch controller
-      processed_env[key].should == op_params["headers"]["foo"]
+      expect(processed_env[key]).to eq(op_params["headers"]["foo"])
     end
 
     it "preserves existing headers" do
-      processed_env["HTTP_PREVIOUS_HEADERS"].should == env["HTTP_PREVIOUS_HEADERS"]
+      expect(processed_env["HTTP_PREVIOUS_HEADERS"]).to eq(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"
+      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"
-      processed_env[key].should_not == env[key]
-      processed_env[key].should == env["REQUEST_URI"].gsub(/\/batch.*/, op_params["url"])
+      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"
-      processed_env[key].should_not == env[key]
-      processed_env[key].should == op_params["url"].split("?").first
+      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"
-      processed_env[key].should_not == env[key]
-      processed_env[key].should == op_params["url"]
+      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"
-      processed_env[key].should_not == env[key]
-      processed_env[key].should == op_params["url"]
+      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"
-      processed_env[key].should_not == env[key]
-      processed_env[key].should == op_params["url"].split("?").last
+      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"
-      processed_env[key].should_not == env[key]
-      processed_env[key].should == op_params["url"].split("?").last
+      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"
-      processed_env[key].should_not == env[key]
-      processed_env[key].should == op_params["params"]
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(op_params["params"])
     end
 
     context "query_hash" do
@@ -144,14 +152,14 @@ describe BatchApi::Operation::Rack 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"]
+        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"
-        processed_env[key].should_not == env[key]
-        processed_env[key].should be_nil
+        expect(processed_env[key]).not_to eq(env[key])
+        expect(processed_env[key]).to be_nil
       end
     end
   end
@@ -161,39 +169,39 @@ describe BatchApi::Operation::Rack do
       let(:result) { [
         200,
         {header: "footer"},
-        stub(body: "{\"data\":2}", cookies: nil)
+        double(body: "{\"data\":2}", cookies: nil)
       ] }
-      let(:processed_env) { stub }
+      let(:processed_env) { double }
 
       before :each do
-        operation.stub(:process_env) { operation.env = processed_env }
+        allow(operation).to receive(:process_env) { operation.env = processed_env }
       end
 
       it "executes the call with the application" do
-        app.should_receive(:call).with(processed_env)
+        expect(app).to 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
+        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 = stub, stub, stub
-        b_err = stub("batch error", render: rendered)
+        result, rendered, response = double, double, double
+        b_err = double("batch error", render: rendered)
 
         # simulate the error
-        app.stub(:call).and_raise(err)
+        allow(app).to receive(:call).and_raise(err)
         # we'll create the BatchError
-        BatchApi::ErrorWrapper.should_receive(:new).with(err).and_return(b_err)
+        expect(BatchApi::ErrorWrapper).to receive(:new).with(err).and_return(b_err)
         # render that as the response
-        BatchApi::Response.should_receive(:new).with(rendered).and_return(response)
+        expect(BatchApi::Response).to receive(:new).with(rendered).and_return(response)
         # and return the response overall
-        operation.execute.should == response
+        expect(operation.execute).to eq(response)
       end
     end
   end
@@ -208,7 +216,7 @@ describe BatchApi::Operation::Rack do
       "REMOTE_ADDR"=>"127.0.0.1",
       "REMOTE_HOST"=>"1035.spotilocal.com",
       "REQUEST_METHOD"=>"REPORT",
-      "REQUEST_URI"=>"http://localhost:3000/batch",
+      "REQUEST_URI"=>"http://localhost:3000/api/batch",
       "SCRIPT_NAME"=>"",
       "SERVER_NAME"=>"localhost",
       "SERVER_PORT"=>"3000",
@@ -226,8 +234,8 @@ describe BatchApi::Operation::Rack do
       "rack.run_once"=>false,
       "rack.url_scheme"=>"http",
       "HTTP_VERSION"=>"HTTP/1.1",
-      "REQUEST_PATH"=>"/batch",
-      "ORIGINAL_FULLPATH"=>"/batch",
+      "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\":{}}",