requests_spec.rb in grape-batch-1.1.2

- old
+ new

@@ -3,10 +3,14 @@
 require 'grape/batch'
 require 'grape'
 require 'api'
 
 RSpec.describe Grape::Batch::Base do
+  before(:all) do
+    Grape::Batch.configuration.logger = Logger.new('/dev/null')
+  end
+
   before :context do
     @app = Twitter::API.new
   end
 
   let(:stack) { Grape::Batch::Base.new(@app) }
@@ -29,19 +33,18 @@
       it { expect(response.body).to eq(encode('world')) }
     end
 
     describe 'GET /failure' do
       let(:response) { request.get('/api/v1/failure') }
-
       it { expect(response.status).to eq(503) }
-      it { expect(response.body).to eq(encode({error: 'Failed as expected'})) }
+      it { expect(response.body).to eq(encode({ error: 'Failed as expected' })) }
     end
   end
 
   describe '/batch' do
     let(:request_body) { nil }
-    let(:response) { request.post('/batch', {'CONTENT_TYPE' => 'application/json', input: request_body}) }
+    let(:response) { request.post('/batch', { 'CONTENT_TYPE' => 'application/json', input: request_body }) }
 
     context 'with invalid body' do
       it { expect(response.status).to eq(400) }
 
       context 'when body == nil' do
@@ -72,92 +75,92 @@
         let(:request_body) { '{}' }
         it { expect(response.body).to eq("'requests' object is missing in request body") }
       end
 
       context "when body['requests'] is not an array" do
-        let(:request_body) { encode({requests: 'request'}) }
+        let(:request_body) { encode({ requests: 'request' }) }
         it { expect(response.body).to eq("'requests' is not well formatted") }
       end
 
       context 'when request limit is exceeded' do
-        let(:request_body) { encode({requests: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) }
+        let(:request_body) { encode({ requests: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] }) }
         it { expect(response.body).to eq('Batch requests limit exceeded') }
       end
 
       describe 'method attribute in request object' do
         context 'method is missing' do
-          let(:request_body) { encode({requests: [{}]}) }
+          let(:request_body) { encode({ requests: [{}] }) }
           it { expect(response.body).to eq("'method' is missing in one of request objects") }
         end
 
         context 'method is not a String' do
-          let(:request_body) { encode({requests: [{method: true}]}) }
+          let(:request_body) { encode({ requests: [{ method: true }] }) }
           it { expect(response.body).to eq("'method' is invalid in one of request objects") }
         end
 
         context 'method is invalid' do
-          let(:request_body) { encode({requests: [{method: 'TRACE'}]}) }
+          let(:request_body) { encode({ requests: [{ method: 'TRACE' }] }) }
           it { expect(response.body).to eq("'method' is invalid in one of request objects") }
         end
       end
 
       describe 'path attribute in request object' do
         context 'path is missing' do
-          let(:request_body) { encode({requests: [{method: 'GET'}]}) }
+          let(:request_body) { encode({ requests: [{ method: 'GET' }] }) }
           it { expect(response.body).to eq("'path' is missing in one of request objects") }
         end
 
         context 'path is not a String' do
-          let(:request_body) { encode({requests: [{method: 'GET', path: 123}]}) }
+          let(:request_body) { encode({ requests: [{ method: 'GET', path: 123 }] }) }
           it { expect(response.body).to eq("'path' is invalid in one of request objects") }
         end
       end
     end
 
     describe 'GET' do
       context 'with no parameters' do
-        let(:request_body) { encode({requests: [{method: 'GET', path: '/api/v1/hello'}]}) }
+        let(:request_body) { encode({ requests: [{ method: 'GET', path: '/api/v1/hello' }] }) }
         it { expect(response.status).to eq(200) }
-        it { expect(response.body).to eq(encode([{success: 'world'}])) }
+        it { expect(response.body).to eq(encode([{ success: 'world' }])) }
       end
 
       context 'with parameters' do
-        let(:request_body) { encode({requests: [{method: 'GET', path: '/api/v1/user/856'}]}) }
+        let(:request_body) { encode({ requests: [{ method: 'GET', path: '/api/v1/user/856' }] }) }
         it { expect(response.status).to eq(200) }
-        it { expect(response.body).to eq(encode([{success: 'user 856'}])) }
+        it { expect(response.body).to eq(encode([{ success: 'user 856' }])) }
       end
 
       context 'with a body' do
-        let(:request_body) { encode({requests: [{method: 'GET', path: '/api/v1/status', body: {id: 856}}]}) }
+        let(:request_body) { encode({ requests: [{ method: 'GET', path: '/api/v1/status', body: { id: 856 } }] }) }
         it { expect(response.status).to eq(200) }
-        it { expect(response.body).to eq(encode([{success: 'status 856'}])) }
+        it { expect(response.body).to eq(encode([{ success: 'status 856' }])) }
       end
 
       describe '404 errors' do
-        let(:request_body) { encode({requests: [{method: 'GET', path: '/api/v1/unknown'}]}) }
+        let(:request_body) { encode({ requests: [{ method: 'GET', path: '/api/v1/unknown' }] }) }
         it { expect(response.status).to eq(200) }
-        it { expect(response.body).to eq(encode([{code: 404, error: '/api/v1/unknown not found'}])) }
+        it { expect(response.body).to eq(encode([{ code: 404, error: '/api/v1/unknown not found' }])) }
       end
     end
 
     describe 'POST' do
       context 'with no parameters' do
-        let(:request_body) { encode({requests: [{method: 'POST', path: '/api/v1/hello'}]}) }
+        let(:request_body) { encode({ requests: [{ method: 'POST', path: '/api/v1/hello' }] }) }
         it { expect(response.status).to eq(200) }
-        it { expect(response.body).to eq(encode([{success: 'world'}])) }
+        it { expect(response.body).to eq(encode([{ success: 'world' }])) }
       end
 
       context 'with a body' do
-        let(:request_body) { encode({requests: [{method: 'POST', path: '/api/v1/status', body: {id: 856}}]}) }
+        let(:request_body) { encode({ requests: [{ method: 'POST', path: '/api/v1/status', body: { id: 856 } }] }) }
         it { expect(response.status).to eq(200) }
-        it { expect(response.body).to eq(encode([{success: 'status 856'}])) }
+        it { expect(response.body).to eq(encode([{ success: 'status 856' }])) }
       end
     end
 
     describe 'POST' do
       context 'with multiple requests' do
-        let(:request_body) { encode({requests: [{method: 'POST', path: '/api/v1/hello'}, {method: 'GET', path: '/api/v1/user/856'}]}) }
+        let(:request_body) { encode({ requests: [{ method: 'POST', path: '/api/v1/hello' }, { method: 'GET', path: '/api/v1/user/856' }] }) }
         it { expect(response.status).to eq(200) }
         it { expect(decode(response.body).size).to eq(2) }
       end
     end
   end
@@ -171,10 +174,10 @@
       it { expect(Grape::Batch.configuration.limit).to eq(10) }
     end
 
     describe '.configure' do
       before do
-        allow(  Grape::Batch).to receive(:configuration) do
+        allow(Grape::Batch).to receive(:configuration) do
           config = Grape::Batch::Configuration.new
           config.path = '/custom_path'
           config.limit = 15
           config
         end