goliath 1.0.4 → 1.0.6

data/spec/unit/api_spec.rb

@@ -7,7 +7,7 @@ describe Goliath::API do
 
   describe "middlewares" do
     it "doesn't change after multi calls" do
-      2.times { DummyApi.should have(2).middlewares }
+      2.times { expect(DummyApi.middlewares.size).to eq(2) }
     end
   end
 end

data/spec/unit/connection_spec.rb

@@ -9,39 +9,39 @@ describe Goliath::Connection do
     it 'accepts an app' do
       app = double('app')
       @c.app = app
-      @c.app.should == app
+      expect(@c.app).to eq(app)
     end
 
     it 'accepts a logger' do
       logger = double('logger')
       @c.logger = logger
-      @c.logger.should == logger
+      expect(@c.logger).to eq(logger)
     end
 
     it 'accepts a status object' do
       status = double('status')
       @c.status = status
-      @c.status.should == status
+      expect(@c.status).to eq(status)
     end
 
     it 'accepts config' do
       config = double('config')
       @c.config = config
-      @c.config.should == config
+      expect(@c.config).to eq(config)
     end
   end
 
   describe 'post_init' do
     it 'sets up the parser' do
       @c.post_init
-      @c.instance_variable_get("@parser").should_not be_nil
+      expect(@c.instance_variable_get("@parser")).not_to be_nil
     end
   end
 
   describe 'receive_data' do
     it 'passes data to the http parser' do
       request_mock = double("parser").as_null_object
-      request_mock.should_receive(:<<)
+      expect(request_mock).to receive(:<<)
 
       current_mock = double("current").as_null_object
 
@@ -52,10 +52,10 @@ describe Goliath::Connection do
 
     it "closes the connection when a parse error is received" do
       current_mock = double("current").as_null_object
-      current_mock.should_receive(:close)
+      expect(current_mock).to receive(:close)
 
       @c.instance_variable_set("@current", current_mock)
-      lambda { @c.receive_data("bad data") }.should_not raise_error
+      expect { @c.receive_data("bad data") }.not_to raise_error
     end
   end
 

data/spec/unit/console_spec.rb

@@ -9,9 +9,9 @@ describe Goliath::Console do
 
   describe 'run!' do
     it "starts a irb session" do
-      Object.should_receive(:send).with(:define_method, :goliath_server)
-      IRB.should_receive(:start)
-      @server.should_receive(:load_config)
+      expect(Object).to receive(:send).with(:define_method, :goliath_server)
+      expect(IRB).to receive(:start)
+      expect(@server).to receive(:load_config)
       Goliath::Console.run!(@server)
     end
   end

data/spec/unit/env_spec.rb

@@ -7,49 +7,49 @@ describe Goliath::Env do
   end
 
   it 'responds to []=' do
-    lambda { @env['test'] = 'blah' }.should_not raise_error
+    expect { @env['test'] = 'blah' }.not_to raise_error
   end
 
   it 'responds to []' do
     @env['test'] = 'blah'
-    lambda { @env['test'].should == 'blah' }.should_not raise_error
+    expect { expect(@env['test']).to eq('blah') }.not_to raise_error
   end
 
   context '#method_missing' do
     it 'allows access to items as methods' do
       @env['db'] = 'test'
-      @env.db.should == 'test'
+      expect(@env.db).to eq('test')
     end
 
     it 'allows access to config items as methods' do
       @env['config'] = {}
       @env['config']['db'] = 'test'
-      @env.db.should == 'test'
+      expect(@env.db).to eq('test')
     end
   end
 
   context '#respond_to?' do
     it 'returns true for items in the hash' do
       @env['test'] = 'true'
-      @env.respond_to?(:test).should be_true
+      expect(@env.respond_to?(:test)).to be true
     end
 
     it 'returns false for items not in hash' do
-      @env.respond_to?(:test).should be_false
+      expect(@env.respond_to?(:test)).to be false
     end
 
     it 'returns true for items in the config hash' do
       @env['config'] = {'test' => true}
-      @env.respond_to?(:test).should be_true
+      expect(@env.respond_to?(:test)).to be true
     end
 
     it 'returns false for items not in the config hash' do
       @env['config'] = {}
-      @env.respond_to?(:test).should be_false
+      expect(@env.respond_to?(:test)).to be false
     end
 
     it 'delegates if not found' do
-      @env.respond_to?(:[]).should be_true
+      expect(@env.respond_to?(:[])).to be true
     end
   end
 end

data/spec/unit/headers_spec.rb

@@ -8,46 +8,46 @@ describe Goliath::Headers do
 
   it 'outputs in the correct format' do
     @h['my_header'] = 'my_value'
-    @h.to_s.should == "my_header: my_value\r\n"
+    expect(@h.to_s).to eq("my_header: my_value\r\n")
   end
 
   it 'suppresses duplicate keys' do
     @h['my_header'] = 'my_value1'
     @h['my_header'] = 'my_value2'
-    @h.to_s.should == "my_header: my_value1\r\n"
+    expect(@h.to_s).to eq("my_header: my_value1\r\n")
   end
 
   it 'returns true if a key has been set' do
     @h['my_header'] = 'my_value'
-    @h.has_key?('my_header').should be_true
+    expect(@h.has_key?('my_header')).to be true
   end
 
   it 'returns false if the key has not been set' do
-    @h.has_key?('my_header').should be_false
+    expect(@h.has_key?('my_header')).to be false
   end
 
   it 'ignores nil values' do
     @h['my_header'] = nil
-    @h.to_s.should == ''
+    expect(@h.to_s).to eq('')
   end
 
   it 'allows a value after setting nil' do
     @h['my_header'] = nil
     @h['my_header'] = 'my_value'
-    @h.to_s.should == "my_header: my_value\r\n"
+    expect(@h.to_s).to eq("my_header: my_value\r\n")
   end
 
   it 'formats time as an http time' do
     time = Time.now
     @h['my_time'] = time
-    @h.to_s.should == "my_time: #{time.httpdate}\r\n"
+    expect(@h.to_s).to eq("my_time: #{time.httpdate}\r\n")
   end
 
   %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate).each do |key|
     it "allows #{key} as to be duplicate" do
       @h[key] = 'value1'
       @h[key] = 'value2'
-      @h.to_s.should == "#{key}: value1\r\n#{key}: value2\r\n"
+      expect(@h.to_s).to eq("#{key}: value1\r\n#{key}: value2\r\n")
     end
   end
 end

data/spec/unit/rack/default_mime_type_spec.rb

@@ -14,21 +14,21 @@ describe Goliath::Rack::DefaultMimeType do
   context 'accept header cleanup' do
     it 'handles a nil header' do
       env['HTTP_ACCEPT'] = nil
-      lambda { dmt.call(env) }.should_not raise_error
+      expect { dmt.call(env) }.not_to raise_error
     end
 
     %w(gzip deflate compressed identity).each do |type|
       it "removes #{type} from the accept header" do
         env['HTTP_ACCEPT'] = "text/html, #{type}, text/javascript"
         dmt.call(env)
-        env['HTTP_ACCEPT'].should == 'text/html, text/javascript'
+        expect(env['HTTP_ACCEPT']).to eq('text/html, text/javascript')
       end
     end
 
     it 'sets to */* if all entries removed' do
       env['HTTP_ACCEPT'] = 'identity'
       dmt.call(env)
-      env['HTTP_ACCEPT'].should == '*/*'
+      expect(env['HTTP_ACCEPT']).to eq('*/*')
     end
   end
 end

data/spec/unit/rack/formatters/json_spec.rb

@@ -3,7 +3,7 @@ require 'goliath/rack/formatters/json'
 
 describe Goliath::Rack::Formatters::JSON do
   it 'accepts an app' do
-    lambda { Goliath::Rack::Formatters::JSON.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Formatters::JSON.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -13,41 +13,63 @@ describe Goliath::Rack::Formatters::JSON do
     end
 
     it 'checks content type for application/json' do
-      @js.json_response?({'Content-Type' => 'application/json'}).should be_true
+      expect(@js.json_response?({'Content-Type' => 'application/json'})).to be_truthy
+    end
+
+    it 'checks content type for application/vnd.api+json' do
+      expect(@js.json_response?({'Content-Type' => 'application/vnd.api+json'})).to be_truthy
+    end
+
+    it 'checks content type for application/javascript' do
+      expect(@js.json_response?({'Content-Type' => 'application/javascript'})).to be_truthy
     end
 
     it 'returns false for non-applicaton/json types' do
-      @js.json_response?({'Content-Type' => 'application/xml'}).should be_false
+      expect(@js.json_response?({'Content-Type' => 'application/xml'})).to be_falsey
     end
 
     it 'calls the app with the provided environment' do
       env_mock = double('env').as_null_object
-      @app.should_receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
+      expect(@app).to receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
       @js.call(env_mock)
     end
 
     it 'formats the body into json if content-type is json' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+
+      status, header, body = @js.call({})
+      expect { expect(MultiJson.load(body.first)['a']).to eq(1) }.not_to raise_error
+    end
+
+    it 'formats the body into json if content-type is vnd.api+json' do
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/vnd.api+json'}, {:a => 1, :b => 2}])
+
+      status, header, body = @js.call({})
+      expect { expect(MultiJson.load(body.first)['a']).to eq(1) }.not_to raise_error
+    end
+
+    it 'formats the body into json if content-type is javascript' do
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/javascript'}, {:a => 1, :b => 2}])
 
       status, header, body = @js.call({})
-      lambda { MultiJson.load(body.first)['a'].should == 1 }.should_not raise_error
+      expect { expect(MultiJson.load(body.first)['a']).to eq(1) }.not_to raise_error
     end
 
     it "doesn't format to json if the type is not application/json" do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      MultiJson.should_not_receive(:dump)
+      expect(MultiJson).not_to receive(:dump)
       status, header, body = @js.call({})
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      MultiJson.should_not_receive(:dump)
+      expect(MultiJson).not_to receive(:dump)
       status, header, body = @js.call({})
-      status.should == 200
-      header.should == {'Content-Type' => 'application/xml'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/xml'})
     end
   end
 end

data/spec/unit/rack/formatters/plist_spec.rb

@@ -17,7 +17,7 @@ describe Goliath::Rack::Formatters::PLIST do
   end
 
   it 'accepts an app' do
-    lambda { Goliath::Rack::Formatters::PLIST.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Formatters::PLIST.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -27,23 +27,23 @@ describe Goliath::Rack::Formatters::PLIST do
     end
 
     it 'formats the body into plist if content-type is plist' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/x-plist'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/x-plist'}, {:a => 1, :b => 2}])
 
       status, header, body = @m.call({})
-      body.should == ["plist: {:a=>1, :b=>2}"]
+      expect(body).to eq(["plist: {:a=>1, :b=>2}"])
     end
 
     it "doesn't format to plist if the type is not plist" do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
       status, header, body = @m.call({})
-      status.should == 200
-      header.should == {'Content-Type' => 'application/xml'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/xml'})
 
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
       status, header, body = @m.call({})
     end

data/spec/unit/rack/formatters/xml_spec.rb

@@ -4,7 +4,7 @@ require 'nokogiri'
 
 describe Goliath::Rack::Formatters::XML do
   it 'accepts an app' do
-    lambda { Goliath::Rack::Formatters::XML.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Formatters::XML.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -14,52 +14,52 @@ describe Goliath::Rack::Formatters::XML do
     end
 
     it 'checks content type for application/xml' do
-      @xml.xml_response?({'Content-Type' => 'application/xml'}).should be_true
+      expect(@xml.xml_response?({'Content-Type' => 'application/xml'})).to be_truthy
     end
 
     it 'returns false for non-applicaton/xml types' do
-      @xml.xml_response?({'Content-Type' => 'application/json'}).should be_false
+      expect(@xml.xml_response?({'Content-Type' => 'application/json'})).to be_falsey
     end
 
     it 'calls the app with the provided environment' do
       env_mock = double('env').as_null_object
-      @app.should_receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
+      expect(@app).to receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
       @xml.call(env_mock)
     end
 
     it 'formats the body into xml if content-type is xml' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
       status, header, body = @xml.call({})
-      lambda { Nokogiri.parse(body.first).search('a').inner_text.should == '1' }.should_not raise_error
+      expect { expect(Nokogiri.parse(body.first).search('a').inner_text).to eq('1') }.not_to raise_error
     end
 
     it 'generates arrays correctly' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, [1, 2]])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, [1, 2]])
 
       status, header, body = @xml.call({})
-      lambda {
+      expect {
         doc = Nokogiri.parse(body.first)
-        doc.search('item').first.inner_text.should == '1'
-        doc.search('item').last.inner_text.should == '2'
-      }.should_not raise_error
+        expect(doc.search('item').first.inner_text).to eq('1')
+        expect(doc.search('item').last.inner_text).to eq('2')
+      }.not_to raise_error
     end
 
     it "doesn't format to xml if the type is not application/xml" do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
 
-      @xml.should_not_receive(:to_xml)
+      expect(@xml).not_to receive(:to_xml)
       status, header, body = @xml.call({})
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
 
-      @xml.should_not_receive(:to_xml)
+      expect(@xml).not_to receive(:to_xml)
       status, header, body = @xml.call({})
-      status.should == 200
-      header.should == {'Content-Type' => 'application/json'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/json'})
     end
   end
 end

data/spec/unit/rack/formatters/yaml_spec.rb

@@ -3,7 +3,7 @@ require 'goliath/rack/formatters/yaml'
 
 describe Goliath::Rack::Formatters::YAML do
   it 'accepts an app' do
-    lambda { Goliath::Rack::Formatters::YAML.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Formatters::YAML.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -13,41 +13,41 @@ describe Goliath::Rack::Formatters::YAML do
     end
 
     it 'checks content type for text/yaml' do
-      @ym.yaml_response?({'Content-Type' => 'text/yaml'}).should be_true
+      expect(@ym.yaml_response?({'Content-Type' => 'text/yaml'})).to be_truthy
     end
 
     it 'returns false for non-applicaton/yaml types' do
-      @ym.yaml_response?({'Content-Type' => 'application/xml'}).should be_false
+      expect(@ym.yaml_response?({'Content-Type' => 'application/xml'})).to be_falsey
     end
 
     it 'calls the app with the provided environment' do
       env_mock = double('env').as_null_object
-      @app.should_receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
+      expect(@app).to receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
       @ym.call(env_mock)
     end
 
     it 'formats the body into yaml if content-type is yaml' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'text/yaml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'text/yaml'}, {:a => 1, :b => 2}])
 
       status, header, body = @ym.call({})
-      lambda { YAML.load(body.first)[:a].should == 1 }.should_not raise_error
+      expect { expect(YAML.load(body.first)[:a]).to eq(1) }.not_to raise_error
     end
 
     it "doesn't format to yaml if the type is not text/yaml" do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      YAML.should_not_receive(:encode)
+      expect(YAML).not_to receive(:encode)
       status, header, body = @ym.call({})
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      YAML.should_not_receive(:encode)
+      expect(YAML).not_to receive(:encode)
       status, header, body = @ym.call({})
-      status.should == 200
-      header.should == {'Content-Type' => 'application/xml'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/xml'})
     end
   end
 end

data/spec/unit/rack/heartbeat_spec.rb

@@ -4,7 +4,7 @@ require 'goliath/env'
 
 describe Goliath::Rack::Heartbeat do
   it 'accepts an app' do
-    lambda { Goliath::Rack::Heartbeat.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Heartbeat.new('my app') }.not_to raise_error
   end
 
   describe 'with the middleware' do
@@ -16,54 +16,54 @@ describe Goliath::Rack::Heartbeat do
     end
 
     it 'allows /status as a path prefix' do
-      @app.should_receive(:call)
+      expect(@app).to receive(:call)
       @env['PATH_INFO'] = '/status_endpoint'
       @hb.call(@env)
     end
 
     it "doesn't call the app when request /status" do
-      @app.should_not_receive(:call)
+      expect(@app).not_to receive(:call)
       @env['PATH_INFO'] = '/status'
       @hb.call(@env)
     end
 
     it 'returns the status, headers and body from the app on non-/status' do
       @env['PATH_INFO'] = '/v1'
-      @app.should_receive(:call).and_return([200, {'a' => 'b'}, {'c' => 'd'}])
+      expect(@app).to receive(:call).and_return([200, {'a' => 'b'}, {'c' => 'd'}])
       status, headers, body = @hb.call(@env)
-      status.should == 200
-      headers.should == {'a' => 'b'}
-      body.should == {'c' => 'd'}
+      expect(status).to eq(200)
+      expect(headers).to eq({'a' => 'b'})
+      expect(body).to eq({'c' => 'd'})
     end
 
     it 'returns the correct status, headers and body on /status' do
       @env['PATH_INFO'] = '/status'
       status, headers, body = @hb.call(@env)
-      status.should == 200
-      headers.should == {}
-      body.should == 'OK'
+      expect(status).to eq(200)
+      expect(headers).to eq({})
+      expect(body).to eq('OK')
     end
 
     it 'allows path and response to be set using options' do
       @hb = Goliath::Rack::Heartbeat.new(@app, :path => '/isup', :response => [204, {}, nil])
       @env['PATH_INFO'] = '/isup'
       status, headers, body = @hb.call(@env)
-      status.should == 204
-      headers.should == {}
-      body.should == nil
+      expect(status).to eq(204)
+      expect(headers).to eq({})
+      expect(body).to eq(nil)
     end
 
     it 'does not log the request by default' do
       @env['PATH_INFO'] = '/status'
       @hb.call(@env)
-      @env[Goliath::Constants::RACK_LOGGER].should == Log4r::Logger.root
+      expect(@env[Goliath::Constants::RACK_LOGGER]).to eq(Log4r::Logger.root)
     end
 
     it 'logs the request only if asked' do
       @env['PATH_INFO'] = '/status'
       @hb = Goliath::Rack::Heartbeat.new(@app, :log => true)
       @hb.call(@env)
-      @env[Goliath::Constants::RACK_LOGGER].should_not == Log4r::Logger.root
+      expect(@env[Goliath::Constants::RACK_LOGGER]).not_to eq(Log4r::Logger.root)
     end
   end
 end