batch_api 0.2.1 → 0.3.0

data/spec/lib/operation/rails_spec.rb

@@ -12,27 +12,27 @@ describe BatchApi::Operation::Rails do
 
   # 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(: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
-    ::Rails.application.routes.stub(:recognize_path).and_return(path_params)
+    allow(::Rails.application.routes).to receive(: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(
+      expect(::Rails.application.routes).to receive(:recognize_path).with(
         op_params["url"],
         op_params
       ).and_return(path_params)
 
-      operation.params.should include(path_params)
+      expect(operation.params).to 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"]
+      allow(::Rails.application.routes).to receive(:recognize_path).and_raise(StandardError)
+      expect(operation.params).to eq(op_params["params"])
     end
   end
 
@@ -41,14 +41,14 @@ describe BatchApi::Operation::Rails do
 
     it "updates the ActionDispatch params" do
       key = "action_dispatch.request.parameters"
-      processed_env[key].should_not == env[key]
-      processed_env[key].should == mixed_params
+      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"
-      processed_env[key].should_not == env[key]
-      processed_env[key].should == mixed_params
+      expect(processed_env[key]).not_to eq(env[key])
+      expect(processed_env[key]).to eq(mixed_params)
     end
   end
 

data/spec/lib/processor/executor_spec.rb

@@ -3,20 +3,20 @@ require 'batch_api/processor/executor'
 
 describe BatchApi::Processor::Executor do
 
-  let(:app) { stub("app", call: stub) }
+  let(:app) { double("app", call: double) }
   let(:executor) { BatchApi::Processor::Executor.new(app) }
-  let(:result) { stub("result") }
-  let(:op) { stub("operation", execute: result) }
+  let(:result) { double("result") }
+  let(:op) { double("operation", execute: result) }
   let(:env) { {op: op} }
 
   describe "#call" do
     it "executes the operation" do
-      op.should_receive(:execute)
+      expect(op).to receive(:execute)
       executor.call(env)
     end
 
     it "returns the result" do
-      executor.call(env).should == result
+      expect(executor.call(env)).to eq(result)
     end
   end
 end

data/spec/lib/processor/sequential_spec.rb

@@ -2,38 +2,38 @@ require 'spec_helper'
 
 describe BatchApi::Processor::Sequential do
 
-  let(:app) { stub("app", call: stub) }
+  let(:app) { double("app", call: double) }
   let(:sequential) { BatchApi::Processor::Sequential.new(app) }
 
   describe "#call" do
-    let(:call_results) { 3.times.collect {|i| stub("called #{i}") } }
+    let(:call_results) { 3.times.collect {|i| double("called #{i}") } }
     let(:env) { {
-      ops: 3.times.collect {|i| stub("op #{i}") }
+      ops: 3.times.collect {|i| double("op #{i}") }
     } }
-    let(:op_middleware) { stub("middleware", call: {}) }
+    let(:op_middleware) { double("middleware", call: {}) }
 
     before :each do
-      BatchApi::InternalMiddleware.
-        stub(:operation_stack).and_return(op_middleware)
-      op_middleware.stub(:call).and_return(*call_results)
+      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|
-        op_middleware.should_receive(:call).
+        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
-      op_middleware.should_receive(:call).
+      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
-      sequential.call(env).should == call_results
+      expect(sequential.call(env)).to eq(call_results)
     end
   end
 end

data/spec/lib/processor_spec.rb

@@ -26,36 +26,36 @@ describe BatchApi::Processor do
 
   let(:request) {
     Rack::Request.new(env).tap do |r|
-      r.stub(:params).and_return({}.merge("ops" => ops).merge(options))
+      allow(r).to receive(:params).and_return({}.merge("ops" => ops).merge(options))
     end
   }
-  let(:app) { stub("application", call: [200, {}, ["foo"]]) }
+  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 = stub("op class")
-      BatchApi::Processor.stub(:operation_klass).and_return(klass)
-      operation_objects = 3.times.collect { stub("operation object") }
+      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|
-        stub("raw operation").tap do |o|
-          klass.should_receive(:new)
+        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
-      BatchApi::Processor.new(request, app).ops.should == operation_objects
+      expect(BatchApi::Processor.new(request, app).ops).to eq(operation_objects)
     end
 
     it "makes the options available" do
-      BatchApi::Processor.new(request, app).options.should == options
+      expect(BatchApi::Processor.new(request, app).options).to eq(options)
     end
 
     it "makes the app available" do
-      BatchApi::Processor.new(request, app).app.should == app
+      expect(BatchApi::Processor.new(request, app).app).to eq(app)
     end
 
     context "error conditions" do
@@ -89,13 +89,13 @@ describe BatchApi::Processor do
 
   describe "#strategy" do
     it "returns BatchApi::Processor::Sequential" do
-      processor.strategy.should == BatchApi::Processor::Sequential
+      expect(processor.strategy).to eq(BatchApi::Processor::Sequential)
     end
   end
 
   describe "#execute!" do
-    let(:result) { stub("result") }
-    let(:stack) { stub("stack", call: result) }
+    let(:result) { double("result") }
+    let(:stack) { double("stack", call: result) }
     let(:middleware_env) { {
       ops: processor.ops, # the processed Operation objects
       rack_env: env,
@@ -104,31 +104,33 @@ describe BatchApi::Processor do
     } }
 
     before :each do
-      BatchApi::InternalMiddleware.stub(:batch_stack).and_return(stack)
+      allow(BatchApi::InternalMiddleware).to receive(:batch_stack).and_return(stack)
     end
 
     it "calls an internal middleware stacks with the appropriate data" do
-      stack.should_receive(:call).with(middleware_env)
+      expect(stack).to 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
+      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
-      BatchApi.stub(:rails?).and_return(false)
-      BatchApi::Processor.operation_klass.should ==
+      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
-      BatchApi.stub(:rails?).and_return(true)
-      BatchApi::Processor.operation_klass.should ==
+      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

@@ -4,17 +4,17 @@ 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|
+      middleware = BatchApi::RackMiddleware.new(double("app")) do |conf|
         conf.limit = limit
       end
-      BatchApi.config.limit.should == limit
+      expect(BatchApi.config.limit).to eq(limit)
     end
   end
 
   describe "#call" do
     let(:endpoint) { "/foo/bar" }
     let(:verb) { "run" }
-    let(:app) { stub("app") }
+    let(:app) { double("app") }
 
     let(:middleware) {
       BatchApi::RackMiddleware.new(app) do |conf|
@@ -47,42 +47,42 @@ describe BatchApi::RackMiddleware do
 
       let(:request) { Rack::Request.new(env) }
       let(:result) { {a: 2, b: {c: 3}} }
-      let(:processor) { stub("processor", :execute! => result) }
+      let(:processor) { double("processor", :execute! => result) }
 
       before :each do
-        BatchApi::Processor.stub(:new).and_return(processor)
+        allow(BatchApi::Processor).to receive(: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)
+        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)
-          output[2].should == [MultiJson.dump(result)]
+          expect(output[2]).to eq([MultiJson.dump(result)])
         end
 
         it "returns a 200" do
-          middleware.call(env)[0].should == 200
+          expect(middleware.call(env)[0]).to eq(200)
         end
 
         it "sets the content type" do
-          middleware.call(env)[1].should include("Content-Type" => "application/json")
+          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, stub
-          error = stub("error object", render: result)
-          BatchApi::Processor.stub(:new).and_raise(err)
-          BatchApi::ErrorWrapper.should_receive(:new).with(err).and_return(
+          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
           )
-          middleware.call(env).should == result
+          expect(middleware.call(env)).to eq(result)
         end
       end
     end
@@ -94,8 +94,8 @@ describe BatchApi::RackMiddleware do
       } }
 
       it "just calls the app onward and returns the result" do
-        output = stub("output")
-        app.should_receive(:call).with(env).and_return(output)
+        output = double("output")
+        expect(app).to receive(:call).with(env).and_return(output)
         middleware.call(env)
       end
     end

data/spec/lib/response_spec.rb

@@ -9,45 +9,45 @@ describe BatchApi::Response do
   [:status, :body, :headers].each do |attr|
     local_attr = attr
     it "has an accessor for #{local_attr}" do
-      response.should respond_to(local_attr)
+      expect(response).to respond_to(local_attr)
     end
   end
 
   describe "#initialize" do
     it "sets status to the HTTP status code" do
-      response.status.should == raw_response.first
+      expect(response.status).to eq(raw_response.first)
     end
 
     it "sets body to the HTTP body turned into a string" do
-      response.body.should == raw_response[2].join
+      expect(response.body).to eq(raw_response[2].join)
     end
 
     it "sets headers to the HTTP headers" do
-      response.headers.should == raw_response[1]
+      expect(response.headers).to eq(raw_response[1])
     end
   end
 
   describe "#as_json" do
     it "creates the expected hash" do
-      response.as_json.should == {
+      expect(response.as_json).to eq({
         body: response.body,
         status: response.status,
         headers: response.headers
-      }
+      })
     end
 
     it "accepts options" do
-      response.as_json(foo: :bar).should_not be_nil
+      expect(response.as_json(foo: :bar)).not_to be_nil
     end
 
     it "leaves out items that are blank" do
       response.status = response.body = nil
-      response.as_json.should == {headers: raw_response[1]}
+      expect(response.as_json).to eq({headers: raw_response[1]})
     end
 
     it "includes items that are false" do
       response.body = false
-      response.as_json[:body].should == false
+      expect(response.as_json[:body]).to eq(false)
     end
   end
 end

data/spec/{integration → rack-integration}/rails_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 require_relative './shared_examples'
 
-describe "Rails integration specs" do
+describe "Rails integration specs", type: :request do
   before :each do
-    BatchApi.stub(:rails?).and_return(true)
+    allow(BatchApi).to receive(:rails?).and_return(true)
   end
 
   it_should_behave_like "integrating with a server"
-end
+end

data/spec/{integration → rack-integration}/shared_examples.rb

@@ -1,19 +1,19 @@
 shared_examples_for "a get request" do
   it "returns the body as objects" do
     @result = JSON.parse(response.body)["results"][0]
-    @result["body"].should == get_result[:body]
+    expect(@result["body"]).to eq(get_result[:body])
   end
 
   it "returns the expected status" do
-    @result["status"].should == get_result[:status]
+    expect(@result["status"]).to eq(get_result[:status])
   end
 
   it "returns the expected headers" do
-    @result["headers"].should include(get_result[:headers])
+    expect(@result["headers"]).to include(get_result[:headers])
   end
 
   it "verifies that the right headers were received" do
-    @result["headers"]["REQUEST_HEADERS"].should include(
+    expect(@result["headers"]["REQUEST_HEADERS"]).to include(
       headerize(get_headers)
     )
   end
@@ -32,7 +32,7 @@ shared_examples_for "integrating with a server" do
   end
 
   before :each do
-    BatchApi::ErrorWrapper.stub(:expose_backtrace?).and_return(false)
+    allow(BatchApi::ErrorWrapper).to receive(:expose_backtrace?).and_return(false)
   end
 
   # these are defined in the dummy app's endpoints controller
@@ -142,7 +142,8 @@ shared_examples_for "integrating with a server" do
 
   before :each do
     @t = Time.now
-    xhr :post, "/batch", {
+    begin
+    post "/batch", {
       ops: [
         get_request,
         post_request,
@@ -155,14 +156,19 @@ shared_examples_for "integrating with a server" do
       ],
       sequential: true
     }.to_json, "CONTENT_TYPE" => "application/json"
+    rescue => err
+      puts err.message
+      puts err.backtrace.join("\n")
+      raise
+    end
   end
 
   it "returns a 200" do
-    response.status.should == 200
+    expect(response.status).to eq(200)
   end
 
   it "includes results" do
-    JSON.parse(response.body)["results"].should be_a(Array)
+    expect(JSON.parse(response.body)["results"]).to be_a(Array)
   end
 
   context "for a get request" do
@@ -190,7 +196,7 @@ shared_examples_for "integrating with a server" do
       end
 
       it "properly parses the URL segment as a paramer" do
-        @result["body"].should == parameter_result[:body]
+        expect(@result["body"]).to eq(parameter_result[:body])
       end
     end
   end
@@ -202,19 +208,19 @@ shared_examples_for "integrating with a server" do
       end
 
       it "returns the body as objects (since DecodeJsonBody is default)" do
-        @result["body"].should == post_result[:body]
+        expect(@result["body"]).to eq(post_result[:body])
       end
 
       it "returns the expected status" do
-        @result["status"].should == post_result[:status]
+        expect(@result["status"]).to eq(post_result[:status])
       end
 
       it "returns the expected headers" do
-        @result["headers"].should include(post_result[:headers])
+        expect(@result["headers"]).to include(post_result[:headers])
       end
 
       it "verifies that the right headers were received" do
-        @result["headers"]["REQUEST_HEADERS"].should include(headerize(post_headers))
+        expect(@result["headers"]["REQUEST_HEADERS"]).to include(headerize(post_headers))
       end
     end
   end
@@ -225,13 +231,13 @@ shared_examples_for "integrating with a server" do
     end
 
     it "returns the right status" do
-      @result["status"].should == error_response[:status]
+      expect(@result["status"]).to eq(error_response[:status])
     end
 
     it "returns the right error information" do
       # we don't care about the backtrace,
       # the main thing is that the messsage arrives
-      @result["body"]["error"].should include(error_response[:body]["error"])
+      expect(@result["body"]["error"]).to include(error_response[:body]["error"])
     end
   end
 
@@ -241,7 +247,7 @@ shared_examples_for "integrating with a server" do
     end
 
     it "returns the right status" do
-      @result["status"].should == 404
+      expect(@result["status"]).to eq(404)
     end
   end
 
@@ -251,7 +257,7 @@ shared_examples_for "integrating with a server" do
     end
 
     it "returns nothing" do
-      @result.should == {}
+      expect(@result).to eq({})
     end
   end
 
@@ -261,7 +267,7 @@ shared_examples_for "integrating with a server" do
     end
 
     it "returns a regular result" do
-      @result.keys.should_not be_empty
+      expect(@result.keys).not_to be_empty
     end
   end
 end