goliath 1.0.4 → 1.0.6

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?param}')
+      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

data/spec/unit/server_spec.rb

@@ -8,50 +8,50 @@ describe Goliath::Server do
 
   describe 'defaults' do
     it 'to any interface' do
-      @s.address.should == '0.0.0.0'
+      expect(@s.address).to eq('0.0.0.0')
     end
 
     it 'to port 9000' do
-      @s.port.should == 9000
+      expect(@s.port).to eq(9000)
     end
   end
 
   describe 'configuration' do
     it 'accepts an address and port' do
       @s = Goliath::Server.new('10.2.1.1', 2020)
-      @s.address.should == '10.2.1.1'
-      @s.port.should == 2020
+      expect(@s.address).to eq('10.2.1.1')
+      expect(@s.port).to eq(2020)
     end
 
     it 'accepts a logger' do
       logger = double('logger')
       @s.logger = logger
-      @s.logger.should == logger
+      expect(@s.logger).to eq(logger)
     end
 
     it 'accepts an app' do
       app = double('app')
       @s.app = app
-      @s.app.should == app
+      expect(@s.app).to eq(app)
     end
 
     it 'accepts config' do
       config = double('config')
       @s.config = config
-      @s.config.should == config
+      expect(@s.config).to eq(config)
     end
   end
 
   describe 'startup' do
     before(:each) do
-      EM.should_receive(:synchrony).and_yield
+      expect(EM).to receive(:synchrony).and_yield
     end
 
     it 'starts' do
       addr = '10.2.1.1'
       port = 10000
 
-      EM.should_receive(:start_server).with(addr, port, anything)
+      expect(EM).to receive(:start_server).with(addr, port, anything)
 
       @s.address = addr
       @s.port = port
@@ -62,9 +62,9 @@ describe Goliath::Server do
       app = double('application')
 
       conn = double("connection").as_null_object
-      conn.should_receive(:app=).with(app)
+      expect(conn).to receive(:app=).with(app)
 
-      EM.should_receive(:start_server).and_yield(conn)
+      expect(EM).to receive(:start_server).and_yield(conn)
 
       @s.app = app
       @s.start
@@ -74,9 +74,9 @@ describe Goliath::Server do
       logger = double('logger')
 
       conn = double("connection").as_null_object
-      conn.should_receive(:logger=).with(logger)
+      expect(conn).to receive(:logger=).with(logger)
 
-      EM.should_receive(:start_server).and_yield(conn)
+      expect(EM).to receive(:start_server).and_yield(conn)
 
       @s.logger = logger
       @s.start
@@ -86,9 +86,9 @@ describe Goliath::Server do
       status = double('status')
 
       conn = double("connection").as_null_object
-      conn.should_receive(:status=).with(status)
+      expect(conn).to receive(:status=).with(status)
 
-      EM.should_receive(:start_server).and_yield(conn)
+      expect(EM).to receive(:start_server).and_yield(conn)
 
       @s.status = status
       @s.start
@@ -96,9 +96,9 @@ describe Goliath::Server do
 
     it 'loads the config for each connection' do
       conn = double("connection").as_null_object
-      EM.should_receive(:start_server).and_yield(conn)
+      expect(EM).to receive(:start_server).and_yield(conn)
 
-      @s.should_receive(:load_config)
+      expect(@s).to receive(:load_config)
       @s.start
     end
   end
@@ -113,28 +113,28 @@ describe Goliath::Server do
         Goliath.env = :development
         block_run = false
         @s.environment('development') { block_run = true }
-        block_run.should be_true
+        expect(block_run).to be true
       end
 
       it 'does not execute the block if the environment does not match' do
         Goliath.env = :development
         block_run = false
         @s.environment('test') { block_run = true }
-        block_run.should be_false
+        expect(block_run).to be false
       end
 
       it 'accepts an array of environments' do
         Goliath.env = :development
         block_run = false
         @s.environment(['development', 'test']) { block_run = true }
-        block_run.should be_true
+        expect(block_run).to be true
       end
 
       it 'does not run the block if the environment is not in the array' do
         Goliath.env = :production
         block_run = false
         @s.environment(['development', 'test']) { block_run = true }
-        block_run.should be_false
+        expect(block_run).to be false
       end
     end
   end

data/spec/unit/validation/standard_http_errors_spec.rb

@@ -3,19 +3,19 @@ require 'goliath/validation/standard_http_errors'
 
 describe Goliath::Validation::Error do
   it 'defines exceptions for each standard error response' do
-    lambda { Goliath::Validation::BadRequestError.new }.should_not raise_error
-    Goliath::Validation::BadRequestError.should < Goliath::Validation::Error
+    expect { Goliath::Validation::BadRequestError.new }.not_to raise_error
+    expect(Goliath::Validation::BadRequestError).to be < Goliath::Validation::Error
   end
 
   it 'defines InternalServerError not InternalServerErrorError' do
-    lambda { Goliath::Validation::InternalServerError.new }.should_not raise_error
-    Goliath::Validation::InternalServerError.should < Goliath::Validation::Error
+    expect { Goliath::Validation::InternalServerError.new }.not_to raise_error
+    expect(Goliath::Validation::InternalServerError).to be < Goliath::Validation::Error
   end
 
   it 'sets a default status code and message' do
     nfe = Goliath::Validation::NotFoundError.new
-    nfe.status_code.should == '404'
-    nfe.message.should == 'Not Found'
+    expect(nfe.status_code).to eq('404')
+    expect(nfe.message).to eq('Not Found')
   end
 end