goliath 1.0.5 → 1.0.7

data/spec/unit/rack/validation/required_param_spec.rb

@@ -3,23 +3,23 @@ require 'goliath/rack/validation/required_param'
 
 describe Goliath::Rack::Validation::RequiredParam do
   it 'accepts an app' do
-    lambda { Goliath::Rack::Validation::RequiredParam.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Validation::RequiredParam.new('my app') }.not_to raise_error
   end
 
   it 'accepts options on create' do
     opts = { :type => 1, :key => 2, :message => 'is required' }
-    lambda { Goliath::Rack::Validation::RequiredParam.new('my app', opts) }.should_not raise_error
+    expect { Goliath::Rack::Validation::RequiredParam.new('my app', opts) }.not_to raise_error
   end
 
   it 'defaults type, key and message' do
     @rp = Goliath::Rack::Validation::RequiredParam.new('app')
-    @rp.key.should_not be_nil
-    @rp.key.should_not =~ /^\s*$/
+    expect(@rp.key).not_to be_nil
+    expect(@rp.key).not_to match(/^\s*$/)
 
-    @rp.type.should_not be_nil
-    @rp.type.should_not =~ /^\s*$/
+    expect(@rp.type).not_to be_nil
+    expect(@rp.type).not_to match(/^\s*$/)
 
-    @rp.message.should == 'identifier missing'
+    expect(@rp.message).to eq('identifier missing')
   end
 
   describe 'with middleware' do
@@ -30,76 +30,76 @@ describe Goliath::Rack::Validation::RequiredParam do
     end
 
     it 'stores type and key options' do
-      @rp.type.should == 'Monkey'
-      @rp.key.should == 'mk'
+      expect(@rp.type).to eq('Monkey')
+      expect(@rp.key).to eq('mk')
     end
 
     it 'calls validation_error with a custom message' do
-      @rp.should_receive(:validation_error).with(anything, 'Monkey is required')
+      expect(@rp).to receive(:validation_error).with(anything, 'Monkey is required')
       @rp.call(@env)
     end
 
     it 'returns the app status, headers and body' do
       app_headers = {'Content-Type' => 'app'}
       app_body = {'b' => 'c'}
-      @app.should_receive(:call).and_return([201, app_headers, app_body])
+      expect(@app).to receive(:call).and_return([201, app_headers, app_body])
 
       @env['params']['mk'] = 'monkey'
 
       status, headers, body = @rp.call(@env)
-      status.should == 201
-      headers.should == app_headers
-      body.should == app_body
+      expect(status).to eq(201)
+      expect(headers).to eq(app_headers)
+      expect(body).to eq(app_body)
     end
 
     describe 'key_valid?' do
       it 'raises exception if the key is not provided' do
-        @rp.key_valid?(@env['params']).should be false
+        expect(@rp.key_valid?(@env['params'])).to be false
       end
 
       it 'raises exception if the key is blank' do
         @env['params']['mk'] = ''
-        @rp.key_valid?(@env['params']).should be false
+        expect(@rp.key_valid?(@env['params'])).to be false
       end
 
       it 'raises exception if the key is nil' do
         @env['params']['mk'] = nil
-        @rp.key_valid?(@env['params']).should be false
+        expect(@rp.key_valid?(@env['params'])).to be false
       end
 
       it 'handles an empty array' do
         @env['params']['mk'] = []
-        @rp.key_valid?(@env['params']).should be false
+        expect(@rp.key_valid?(@env['params'])).to be false
       end
 
       it 'handles an array of nils' do
         @env['params']['mk'] = [nil, nil, nil]
-        @rp.key_valid?(@env['params']).should be false
+        expect(@rp.key_valid?(@env['params'])).to be false
       end
 
       it 'handles an array of blanks' do
         @env['params']['mk'] = ['', '', '']
-        @rp.key_valid?(@env['params']).should be false
+        expect(@rp.key_valid?(@env['params'])).to be false
       end
 
       it "doesn't raise if the key provided" do
         @env['params']['mk'] = 'my value'
-        @rp.key_valid?(@env['params']).should be true
+        expect(@rp.key_valid?(@env['params'])).to be true
       end
 
       it "doesn't raise if the array contains valid data" do
         @env['params']['mk'] = [1, 2, 3, 4]
-        @rp.key_valid?(@env['params']).should be true
+        expect(@rp.key_valid?(@env['params'])).to be true
       end
 
       it "doesn't raise if the key provided is multiline and has blanks" do
         @env['params']['mk'] = "my\n  \nvalue"
-        @rp.key_valid?(@env['params']).should be true
+        expect(@rp.key_valid?(@env['params'])).to be true
       end
 
       it "doesn't raise if the key provided is an array and contains multiline with blanks" do
         @env['params']['mk'] = ["my\n  \nvalue", "my\n  \nother\n  \nvalue"]
-        @rp.key_valid?(@env['params']).should be true
+        expect(@rp.key_valid?(@env['params'])).to be true
       end
     end
   end
@@ -123,7 +123,7 @@ describe Goliath::Rack::Validation::RequiredParam do
             }
         }
 
-      @rp.key_valid?(@env['params']).should be false
+      expect(@rp.key_valid?(@env['params'])).to be false
     end
 
     it "return true if key is present" do
@@ -134,7 +134,7 @@ describe Goliath::Rack::Validation::RequiredParam do
             }
         }
 
-      @rp.key_valid?(@env['params']).should be true
+      expect(@rp.key_valid?(@env['params'])).to be true
     end
   end
 
@@ -157,7 +157,7 @@ describe Goliath::Rack::Validation::RequiredParam do
             }
         }
 
-      @rp.key_valid?(@env['params']).should be false
+      expect(@rp.key_valid?(@env['params'])).to be false
     end
 
     it "return true if key is present" do
@@ -168,7 +168,7 @@ describe Goliath::Rack::Validation::RequiredParam do
             }
         }
 
-      @rp.key_valid?(@env['params']).should be true
+      expect(@rp.key_valid?(@env['params'])).to be true
     end
   end
 

data/spec/unit/rack/validation/required_value_spec.rb

@@ -3,18 +3,18 @@ require 'goliath/rack/validation/required_value'
 
 describe Goliath::Rack::Validation::RequiredValue do
   it 'accepts an app' do
-    lambda { Goliath::Rack::Validation::RequiredValue.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Validation::RequiredValue.new('my app') }.not_to raise_error
   end
 
   it 'accepts options on create' do
     opts = { :key => 2, :values => ["foo", "bar"] }
-    lambda { Goliath::Rack::Validation::RequiredValue.new('my app', opts) }.should_not raise_error
+    expect { Goliath::Rack::Validation::RequiredValue.new('my app', opts) }.not_to raise_error
   end
 
 
   it 'turns a single option into an array' do
     rv = Goliath::Rack::Validation::RequiredValue.new('my app', :key => 2, :values => "foo")
-    rv.values.should == ['foo']
+    expect(rv.values).to eq(['foo'])
   end
 
   describe 'with middleware' do
@@ -25,71 +25,71 @@ describe Goliath::Rack::Validation::RequiredValue do
     end
 
     it 'stores type and key options' do
-      @rv.values.should == ['Monkey', 'frog']
-      @rv.key.should == 'mk'
+      expect(@rv.values).to eq(['Monkey', 'frog'])
+      expect(@rv.key).to eq('mk')
     end
 
     it 'returns the app status, headers and body' do
       app_headers = {'Content-Type' => 'app'}
       app_body = {'b' => 'c'}
-      @app.should_receive(:call).and_return([201, app_headers, app_body])
+      expect(@app).to receive(:call).and_return([201, app_headers, app_body])
 
       @env['params']['mk'] = 'Monkey'
 
       status, headers, body = @rv.call(@env)
-      status.should == 201
-      headers.should == app_headers
-      body.should == app_body
+      expect(status).to eq(201)
+      expect(headers).to eq(app_headers)
+      expect(body).to eq(app_body)
     end
 
     context '#value_valid!' do
       it 'raises exception if the key is not provided' do
-        @rv.value_valid?(@env['params']).should be false
+        expect(@rv.value_valid?(@env['params'])).to be false
       end
 
       it 'raises exception if the key is blank' do
         @env['params']['mk'] = ''
-        @rv.value_valid?(@env['params']).should be false
+        expect(@rv.value_valid?(@env['params'])).to be false
       end
 
       it 'raises exception if the key is nil' do
         @env['params']['mk'] = nil
-        @rv.value_valid?(@env['params']).should be false
+        expect(@rv.value_valid?(@env['params'])).to be false
       end
 
       it 'raises exception if the key is does not match' do
         @env['params']['mk'] = "blarg"
-        @rv.value_valid?(@env['params']).should be false
+        expect(@rv.value_valid?(@env['params'])).to be false
       end
 
       it 'handles an empty array' do
         @env['params']['mk'] = []
-        @rv.value_valid?(@env['params']).should be false
+        expect(@rv.value_valid?(@env['params'])).to be false
       end
 
       it 'handles an array of nils' do
         @env['params']['mk'] = [nil, nil, nil]
-        @rv.value_valid?(@env['params']).should be false
+        expect(@rv.value_valid?(@env['params'])).to be false
       end
 
       it 'handles an array of blanks' do
         @env['params']['mk'] = ['', '', '']
-        @rv.value_valid?(@env['params']).should be false
+        expect(@rv.value_valid?(@env['params'])).to be false
       end
 
       it "doesn't raise if the key is value" do
         @env['params']['mk'] = 'Monkey'
-        @rv.value_valid?(@env['params']).should be true
+        expect(@rv.value_valid?(@env['params'])).to be true
       end
 
       it "doesn't raise if the array contains valid data" do
         @env['params']['mk'] = ['Monkey', 'frog']
-        @rv.value_valid?(@env['params']).should be true
+        expect(@rv.value_valid?(@env['params'])).to be true
       end
 
       it 'raises if any of the array elements do not match' do
         @env['params']['mk'] = ["Monkey", "frog", "bat"]
-        @rv.value_valid?(@env['params']).should be false
+        expect(@rv.value_valid?(@env['params'])).to be false
       end
     end
   end

data/spec/unit/request_spec.rb

@@ -14,15 +14,15 @@ describe Goliath::Request do
       env['INIT'] = 'init'
 
       r = Goliath::Request.new(nil, nil, env)
-      r.env['INIT'].should == 'init'
+      expect(r.env['INIT']).to eq('init')
     end
 
     it 'initializes an async callback' do
-      @r.env['async.callback'].should_not be_nil
+      expect(@r.env['async.callback']).not_to be_nil
     end
 
     it 'initializes request' do
-      @r.instance_variable_get("@state").should == :processing
+      expect(@r.instance_variable_get("@state")).to eq(:processing)
     end
   end
 
@@ -32,8 +32,8 @@ describe Goliath::Request do
       env_mock = double('app').as_null_object
       request = Goliath::Request.new(app_mock, nil, env_mock)
 
-      app_mock.should_receive(:call).with(request.env)
-      request.should_receive(:post_process)
+      expect(app_mock).to receive(:call).with(request.env)
+      expect(request).to receive(:post_process)
 
       request.process
     end
@@ -41,50 +41,50 @@ describe Goliath::Request do
 
   describe 'finished?' do
     it "returns false if the request parsing has not yet finished" do
-      @r.finished?.should be false
+      expect(@r.finished?).to be false
     end
 
     it 'returns true if we have finished request parsing' do
-      @r.should_receive(:post_process).and_return(nil)
+      expect(@r).to receive(:post_process).and_return(nil)
       @r.process
 
-      @r.finished?.should be true
+      expect(@r.finished?).to be true
     end
   end
 
   describe 'parse_headers' do
     it 'sets content_type correctly' do
       parser = double('parser').as_null_object
-      parser.stub(:request_url).and_return('')
+      allow(parser).to receive(:request_url).and_return('')
 
       @r.parse_header({'Content-Type' => 'text/plain'}, parser)
-      @r.env['CONTENT_TYPE'].should == 'text/plain'
+      expect(@r.env['CONTENT_TYPE']).to eq('text/plain')
     end
 
     it 'handles bad request urls' do
       parser = double('parser').as_null_object
-      parser.stub(:request_url).and_return('/bad?params##')
+      allow(parser).to receive(:request_url).and_return('/bad?params##')
 
-      @r.stub(:server_exception)
-      @r.should_receive(:server_exception)
+      allow(@r).to receive(:server_exception)
+      expect(@r).to receive(:server_exception)
       @r.parse_header({}, parser)
     end
 
     it 'sets content_length correctly' do
       parser = double('parser').as_null_object
-      parser.stub(:request_url).and_return('')
+      allow(parser).to receive(:request_url).and_return('')
 
       @r.parse_header({'Content-Length' => 42}, parser)
-      @r.env['CONTENT_LENGTH'].should == 42
+      expect(@r.env['CONTENT_LENGTH']).to eq(42)
     end
 
     it 'sets server_name and server_port correctly' do
       parser = double('parser').as_null_object
-      parser.stub(:request_url).and_return('')
+      allow(parser).to receive(:request_url).and_return('')
 
       @r.parse_header({'Host' => 'myhost.com:3000'}, parser)
-      @r.env['SERVER_NAME'].should == 'myhost.com'
-      @r.env['SERVER_PORT'].should == '3000'
+      expect(@r.env['SERVER_NAME']).to eq('myhost.com')
+      expect(@r.env['SERVER_PORT']).to eq('3000')
     end
   end
 end

data/spec/unit/response_spec.rb

@@ -8,28 +8,28 @@ describe Goliath::Response do
 
   it 'allows setting status' do
     @r.status = 400
-    @r.status.should == 400
+    expect(@r.status).to eq(400)
   end
 
   it 'allows setting headers' do
     @r.headers = [['my_key', 'my_headers']]
-    @r.headers.to_s.should == "my_key: my_headers\r\n"
+    expect(@r.headers.to_s).to eq("my_key: my_headers\r\n")
   end
 
   it 'allows setting body' do
     @r.body = 'my body'
-    @r.body.should == 'my body'
+    expect(@r.body).to eq('my body')
   end
 
   it 'sets a default status' do
-    @r.status.should == 200
+    expect(@r.status).to eq(200)
   end
 
   it 'sets default headers' do
-    @r.headers.should_not be_nil
+    expect(@r.headers).not_to be_nil
   end
 
   it 'outputs the http header' do
-    @r.head.should == "HTTP/1.1 200 OK\r\n"
+    expect(@r.head).to eq("HTTP/1.1 200 OK\r\n")
   end
 end

data/spec/unit/runner_spec.rb

@@ -4,23 +4,23 @@ require 'goliath/runner'
 describe Goliath::Runner do
   before(:each) do
     @r = Goliath::Runner.new([], nil)
-    @r.stub(:store_pid)
+    allow(@r).to receive(:store_pid)
 
     @log_mock = double('logger').as_null_object
-    @r.stub(:setup_logger).and_return(@log_mock)
+    allow(@r).to receive(:setup_logger).and_return(@log_mock)
   end
 
   describe 'server execution' do
     describe 'daemonization' do
       it 'daemonizes if specified' do
-        Process.should_receive(:fork)
+        expect(Process).to receive(:fork)
         @r.daemonize = true
         @r.run
       end
 
       it "doesn't daemonize if not specified" do
-        Process.should_not_receive(:fork)
-        @r.should_receive(:run_server)
+        expect(Process).not_to receive(:fork)
+        expect(@r).to receive(:run_server)
         @r.run
       end
     end
@@ -38,46 +38,46 @@ describe Goliath::Runner do
 
       describe 'without setting up file logger' do
         before(:each) do
-          @r.stub(:setup_file_logger)
+          allow(@r).to receive(:setup_file_logger)
         end
 
         it 'configures the logger' do
           log = @r.send(:setup_logger)
-          log.should_not be_nil
+          expect(log).not_to be_nil
         end
 
         [:debug, :warn, :info].each do |type|
           it "responds to #{type} messages" do
             log = @r.send(:setup_logger)
-            log.respond_to?(type).should be true
+            expect(log.respond_to?(type)).to be true
           end
         end
 
         describe 'log level' do
           before(:each) do
-            FileUtils.stub(:mkdir_p)
+            allow(FileUtils).to receive(:mkdir_p)
           end
 
           it 'sets the default log level' do
             log = @r.send(:setup_logger)
-            log.level.should == Log4r::INFO
+            expect(log.level).to eq(Log4r::INFO)
           end
 
           it 'sets debug when verbose' do
             @r.verbose = true
             log = @r.send(:setup_logger)
-            log.level.should == Log4r::DEBUG
+            expect(log.level).to eq(Log4r::DEBUG)
           end
         end
 
         describe 'file logger' do
           it "doesn't configure by default" do
-            @r.should_not_receive(:setup_file_logger)
+            expect(@r).not_to receive(:setup_file_logger)
             log = @r.send(:setup_logger)
           end
 
           it 'configures if -l is provided' do
-            @r.should_receive(:setup_file_logger)
+            expect(@r).to receive(:setup_file_logger)
             @r.log_file = 'out.log'
             log = @r.send(:setup_logger)
           end
@@ -85,12 +85,12 @@ describe Goliath::Runner do
 
         describe 'stdout logger' do
           it "doesn't configure by default" do
-            @r.should_not_receive(:setup_stdout_logger)
+            expect(@r).not_to receive(:setup_stdout_logger)
             log = @r.send(:setup_logger)
           end
 
           it 'configures if -s is provided' do
-            @r.should_receive(:setup_stdout_logger)
+            expect(@r).to receive(:setup_stdout_logger)
             @r.log_stdout = true
             log = @r.send(:setup_logger)
           end
@@ -100,7 +100,7 @@ describe Goliath::Runner do
 
           it "doesn't configure Log4r" do
             CustomLogger = Struct.new(:info, :debug, :error, :fatal)
-            Log4r::Logger.should_not_receive(:new)
+            expect(Log4r::Logger).not_to receive(:new)
             @r.logger = CustomLogger.new
             log = @r.send(:setup_logger)
           end
@@ -109,10 +109,10 @@ describe Goliath::Runner do
       end
 
       it 'creates the log dir if neeed' do
-        Log4r::FileOutputter.stub(:new)
+        allow(Log4r::FileOutputter).to receive(:new)
         log_mock = double('log').as_null_object
 
-        FileUtils.should_receive(:mkdir_p).with('/my/log/dir')
+        expect(FileUtils).to receive(:mkdir_p).with('/my/log/dir')
 
         @r.log_file = '/my/log/dir/log.txt'
         @r.send(:setup_file_logger, log_mock, nil)
@@ -121,34 +121,34 @@ describe Goliath::Runner do
 
     it 'sets up the api if that implements the #setup method' do
       server_mock = double("Server").as_null_object
-      server_mock.api.should_receive(:setup)
+      expect(server_mock.api).to receive(:setup)
 
-      Goliath::Server.stub(:new).and_return(server_mock)
+      allow(Goliath::Server).to receive(:new).and_return(server_mock)
 
-      @r.stub(:load_config).and_return({})
+      allow(@r).to receive(:load_config).and_return({})
       @r.send(:run_server)
     end
 
     it 'runs the server' do
       server_mock = double("Server").as_null_object
-      server_mock.should_receive(:start)
+      expect(server_mock).to receive(:start)
 
-      Goliath::Server.should_receive(:new).and_return(server_mock)
+      expect(Goliath::Server).to receive(:new).and_return(server_mock)
 
-      @r.stub(:load_config).and_return({})
+      allow(@r).to receive(:load_config).and_return({})
       @r.send(:run_server)
     end
 
     it 'configures the server' do
       server_mock = Goliath::Server.new
-      server_mock.stub(:start)
+      allow(server_mock).to receive(:start)
 
       @r.app = 'my_app'
 
-      Goliath::Server.should_receive(:new).and_return(server_mock)
+      expect(Goliath::Server).to receive(:new).and_return(server_mock)
 
-      server_mock.should_receive(:logger=).with(@log_mock)
-      server_mock.should_receive(:app=).with('my_app')
+      expect(server_mock).to receive(:logger=).with(@log_mock)
+      expect(server_mock).to receive(:app=).with('my_app')
 
       @r.send(:run_server)
     end
@@ -161,17 +161,17 @@ describe Goliath::EnvironmentParser do
   end
 
   it 'returns the default environment if no other options are set' do
-    Goliath::EnvironmentParser.parse.should == Goliath::DEFAULT_ENV
+    expect(Goliath::EnvironmentParser.parse).to eq(Goliath::DEFAULT_ENV)
   end
 
   it 'gives precendence to RACK_ENV over the default' do
     ENV['RACK_ENV'] = 'rack_env'
-    Goliath::EnvironmentParser.parse.should == :rack_env
+    expect(Goliath::EnvironmentParser.parse).to eq(:rack_env)
   end
 
   it 'gives precendence to command-line flag over RACK_ENV' do
     ENV['RACK_ENV'] = 'rack_env'
     args = %w{ -e flag_env }
-    Goliath::EnvironmentParser.parse(args).should == :flag_env
+    expect(Goliath::EnvironmentParser.parse(args)).to eq(:flag_env)
   end
 end