restfulness 0.3.2 → 0.3.3

data/spec/unit/resources/authentication_spec.rb

@@ -28,8 +28,8 @@ describe Restfulness::Resources::Authentication do
       obj = AuthResource.new(request, response)
       expect { |b| obj.authenticate_with_http_basic(&b) }.to yield_control
       obj.authenticate_with_http_basic do |username, password|
-        username.should eql('Aladdin')
-        password.should eql('open sesame')
+        expect(username).to eql('Aladdin')
+        expect(password).to eql('open sesame')
       end
     end
 

data/spec/unit/resources/events_spec.rb

@@ -54,7 +54,7 @@ describe Restfulness::Resources::Events do
     end
 
     it "should support bad_request! with paramters" do
-      obj.should_receive(:error!).with(400, {:pay => 'load'}, {})
+      expect(obj).to receive(:error!).with(400, {:pay => 'load'}, {})
       obj.instance_eval do
         bad_request!({:pay => 'load'}, {})
       end

data/spec/unit/response_spec.rb

@@ -25,23 +25,23 @@ describe Restfulness::Response do
 
   describe "#initialize" do
     it "should assign request and headers" do
-      obj.request.should eql(request)
-      obj.headers.should eql({})
-      obj.status.should be_nil
-      obj.payload.should be_nil
+      expect(obj.request).to eql(request)
+      expect(obj.headers).to eql({})
+      expect(obj.status).to be_nil
+      expect(obj.payload).to be_nil
     end
   end
 
   describe "#run" do
     context "without route" do
       it "should not do anything" do
-        request.stub(:route).and_return(nil)
-        request.stub(:uri).and_return(URI('http://test.com/test'))
+        allow(request).to receive(:route).and_return(nil)
+        allow(request).to receive(:uri).and_return(URI('http://test.com/test'))
         obj.run
-        obj.status.should eql(404)
-        obj.payload.should be_empty
-        obj.headers['Content-Type'].should be_nil
-        obj.headers['Content-Length'].should be_nil
+        expect(obj.status).to eql(404)
+        expect(obj.payload).to be_empty
+        expect(obj.headers['Content-Type']).to be_nil
+        expect(obj.headers['Content-Length']).to be_nil
       end
     end
     context "with route" do
@@ -50,46 +50,46 @@ describe Restfulness::Response do
       end
 
       it "should try to build resource and run it" do
-        request.stub(:route).and_return(route)
+        allow(request).to receive(:route).and_return(route)
         request.action = :get
-        request.stub(:uri).and_return(URI('http://test.com/test'))
+        allow(request).to receive(:uri).and_return(URI('http://test.com/test'))
         resource = double(:Resource)
-        resource.should_receive(:check_callbacks)
-        resource.should_receive(:call).and_return({:foo => 'bar'})
-        route.stub(:build_resource).and_return(resource)
+        expect(resource).to receive(:check_callbacks)
+        expect(resource).to receive(:call).and_return({:foo => 'bar'})
+        allow(route).to receive(:build_resource).and_return(resource)
         obj.run 
-        obj.status.should eql(200)
+        expect(obj.status).to eql(200)
         str = "{\"foo\":\"bar\"}"
-        obj.payload.should eql(str)
-        obj.headers['Content-Type'].should match(/application\/json/)
-        obj.headers['Content-Length'].should eql(str.bytesize.to_s)
+        expect(obj.payload).to eql(str)
+        expect(obj.headers['Content-Type']).to match(/application\/json/)
+        expect(obj.headers['Content-Length']).to eql(str.bytesize.to_s)
       end
 
       it "should call resource and set 204 result if no content" do
-        request.stub(:route).and_return(route)
+        allow(request).to receive(:route).and_return(route)
         request.action = :get
-        request.stub(:uri).and_return(URI('http://test.com/test'))
+        allow(request).to receive(:uri).and_return(URI('http://test.com/test'))
         resource = double(:Resource)
-        resource.should_receive(:check_callbacks)
-        resource.should_receive(:call).and_return(nil)
-        route.stub(:build_resource).and_return(resource)
+        expect(resource).to receive(:check_callbacks)
+        expect(resource).to receive(:call).and_return(nil)
+        allow(route).to receive(:build_resource).and_return(resource)
         obj.run
-        obj.status.should eql(204)
-        obj.headers['Content-Type'].should be_nil
-        obj.headers['Content-Length'].should be_nil
+        expect(obj.status).to eql(204)
+        expect(obj.headers['Content-Type']).to be_nil
+        expect(obj.headers['Content-Length']).to be_nil
       end
 
       it "should set string content type if payload is a string" do
-        request.stub(:route).and_return(route)
+        allow(request).to receive(:route).and_return(route)
         request.action = :get
-        request.stub(:uri).and_return(URI('http://test.com/test'))
+        allow(request).to receive(:uri).and_return(URI('http://test.com/test'))
         resource = double(:Resource)
-        resource.should_receive(:check_callbacks)
-        resource.should_receive(:call).and_return("This is a text message")
-        route.stub(:build_resource).and_return(resource)
+        expect(resource).to receive(:check_callbacks)
+        expect(resource).to receive(:call).and_return("This is a text message")
+        allow(route).to receive(:build_resource).and_return(resource)
         obj.run
-        obj.status.should eql(200)
-        obj.headers['Content-Type'].should match(/text\/plain/)
+        expect(obj.status).to eql(200)
+        expect(obj.headers['Content-Type']).to match(/text\/plain/)
       end
     end
 
@@ -99,50 +99,50 @@ describe Restfulness::Response do
       end
 
       it "should update the status and payload" do
-        request.stub(:route).and_return(route)
+        allow(request).to receive(:route).and_return(route)
         request.action = :get
-        request.stub(:uri).and_return(URI('http://test.com/test'))
+        allow(request).to receive(:uri).and_return(URI('http://test.com/test'))
         resource = double(:Resource)
         txt = "This is a text error"
-        resource.stub(:check_callbacks) do
+        allow(resource).to receive(:check_callbacks) do
           raise Restfulness::HTTPException.new(418, txt)
         end
-        route.stub(:build_resource).and_return(resource)
+        allow(route).to receive(:build_resource).and_return(resource)
         obj.run
-        obj.status.should eql(418)
-        obj.headers['Content-Type'].should match(/text\/plain/)
-        obj.payload.should eql(txt)
+        expect(obj.status).to eql(418)
+        expect(obj.headers['Content-Type']).to match(/text\/plain/)
+        expect(obj.payload).to eql(txt)
       end
 
       it "should update the status and provide JSON payload" do
-        request.stub(:route).and_return(route)
+        allow(request).to receive(:route).and_return(route)
         request.action = :get
-        request.stub(:uri).and_return(URI('http://test.com/test'))
+        allow(request).to receive(:uri).and_return(URI('http://test.com/test'))
         resource = double(:Resource)
         err = {:error => "This is a text error"}
-        resource.stub(:check_callbacks) do
+        allow(resource).to receive(:check_callbacks) do
           raise Restfulness::HTTPException.new(418, err)
         end
-        route.stub(:build_resource).and_return(resource)
+        allow(route).to receive(:build_resource).and_return(resource)
         obj.run
-        obj.status.should eql(418)
-        obj.headers['Content-Type'].should match(/application\/json/)
-        obj.payload.should eql(err.to_json)
+        expect(obj.status).to eql(418)
+        expect(obj.headers['Content-Type']).to match(/application\/json/)
+        expect(obj.payload).to eql(err.to_json)
       end
 
       context "for non http errors" do
 
         it "should catch error and provide result" do
-          request.stub(:route).and_return(route)
+          allow(request).to receive(:route).and_return(route)
           request.action = :get
-          request.stub(:uri).and_return(URI('http://test.com/test'))
+          allow(request).to receive(:uri).and_return(URI('http://test.com/test'))
           resource = double(:Resource)
-          resource.stub(:check_callbacks) do
+          allow(resource).to receive(:check_callbacks) do
             raise SyntaxError, 'Bad writing'
           end
-          route.stub(:build_resource).and_return(resource)
+          allow(route).to receive(:build_resource).and_return(resource)
           obj.run
-          obj.status.should eql(500)
+          expect(obj.status).to eql(500)
         end
 
       end

data/spec/unit/route_spec.rb

@@ -18,23 +18,23 @@ describe Restfulness::Route do
 
     it "should assign basic path and resource" do
       obj = klass.new('project', resource)
-      obj.path.should eql(['project'])
-      obj.resource_name.should eql(resource.to_s)
+      expect(obj.path).to eql(['project'])
+      expect(obj.resource_name).to eql(resource.to_s)
     end
 
     it "should assign path with symbols" do
       obj = klass.new('project', :project_id, 'states', resource)
-      obj.path.should eql(['project', :project_id, 'states']) 
+      expect(obj.path).to eql(['project', :project_id, 'states']) 
     end
 
     it "should remove :id from end" do
       obj = klass.new('project', :project_id, 'states', :id, resource)
-      obj.path.should eql(['project', :project_id, 'states'])
+      expect(obj.path).to eql(['project', :project_id, 'states'])
     end
 
     it "should handle numbers in path" do
       obj = klass.new('project', 120, resource)
-      obj.path.should eql(['project', 120])
+      expect(obj.path).to eql(['project', 120])
     end
 
     it "should accept classes as strings" do
@@ -60,7 +60,7 @@ describe Restfulness::Route do
   describe "#resource" do
     it "should provide constant to class" do
       obj = klass.new('project', resource)
-      obj.resource.should eql(resource)
+      expect(obj.resource).to eql(resource)
     end
   end
 
@@ -68,8 +68,8 @@ describe Restfulness::Route do
     it "should build a new path object including self" do
       obj = klass.new('project', resource)
       path = obj.build_path("/project/12345")
-      path.should be_a(Restfulness::Path)
-      path.route.should eql(obj)
+      expect(path).to be_a(Restfulness::Path)
+      expect(path.route).to eql(obj)
     end
   end
 
@@ -80,16 +80,16 @@ describe Restfulness::Route do
         klass.new('project', resource)
       end
       it "should return true for match" do
-        obj.handles?(['project']).should be_true
+        expect(obj.handles?(['project'])).to be true
       end
       it "should return true for match with id" do
-        obj.handles?(['project', '12345']).should be_true
+        expect(obj.handles?(['project', '12345'])).to be true
       end
       it "should return false for different name" do
-        obj.handles?(['projects']).should be_false
+        expect(obj.handles?(['projects'])).to be false
       end
       it "should return false for matching start" do
-        obj.handles?(['project', '12345', 'status']).should be_false
+        expect(obj.handles?(['project', '12345', 'status'])).to be false
       end
     end
 
@@ -98,13 +98,13 @@ describe Restfulness::Route do
         klass.new(resource)
       end
       it "should matching empty path" do
-        obj.handles?([]).should be_true
+        expect(obj.handles?([])).to be true
       end
       it "should matching empty path with id" do
-        obj.handles?(['12345']).should be_true
+        expect(obj.handles?(['12345'])).to be true
       end
       it "shold not match extended URL" do
-        obj.handles?(['foobar', '12345']).should be_false
+        expect(obj.handles?(['foobar', '12345'])).to be false
       end
     end
 
@@ -113,13 +113,13 @@ describe Restfulness::Route do
         klass.new(:project_id, resource)
       end
       it "should matching anything" do
-        obj.handles?(['foobar']).should be_true
+        expect(obj.handles?(['foobar'])).to be true
       end
       it "should matching anything, with id" do
-        obj.handles?(['foobar', '12345']).should be_true
+        expect(obj.handles?(['foobar', '12345'])).to be true
       end
       it "shold not match extended URL" do
-        obj.handles?(['foobar', 'status', '12345']).should be_false
+        expect(obj.handles?(['foobar', 'status', '12345'])).to be false
       end
     end
 
@@ -128,19 +128,19 @@ describe Restfulness::Route do
         klass.new('project', :project_id, 'status', resource)
       end
       it "should return true for match" do
-        obj.handles?(['project', '1234', 'status']).should be_true
+        expect(obj.handles?(['project', '1234', 'status'])).to be true
       end
       it "should return true for match with id" do
-        obj.handles?(['project', '1234', 'status', '12345']).should be_true
+        expect(obj.handles?(['project', '1234', 'status', '12345'])).to be true
       end
       it "should not match short path" do
-        obj.handles?(['project']).should be_false
+        expect(obj.handles?(['project'])).to be false
       end
       it "should not match path with different name" do
-        obj.handles?(['project', '12345', 'statuses']).should be_false
+        expect(obj.handles?(['project', '12345', 'statuses'])).to be false
       end
       it "should not match extended path" do
-        obj.handles?(['project', '12345', 'status', '1234', 'test']).should be_false
+        expect(obj.handles?(['project', '12345', 'status', '1234', 'test'])).to be false
       end
 
     end
@@ -151,7 +151,7 @@ describe Restfulness::Route do
 
     it "should request a new resource" do
       obj = klass.new('project', resource)
-      resource.should_receive(:new).with({}, {}).and_return(nil)
+      expect(resource).to receive(:new).with({}, {}).and_return(nil)
       obj.build_resource({}, {})
     end
 

data/spec/unit/router_spec.rb

@@ -21,14 +21,14 @@ describe Restfulness::Router do
 
     it "should prepare routes" do
       obj = klass.new
-      obj.routes.should eql([])
+      expect(obj.routes).to eql([])
     end
 
     it "should prepare routes with instance eval block" do
       obj = klass.new do
         @foo = 'bar'
       end
-      obj.instance_variable_get(:@foo).should eql('bar')
+      expect(obj.instance_variable_get(:@foo)).to eql('bar')
     end
 
   end
@@ -37,10 +37,10 @@ describe Restfulness::Router do
     it "should add route to object" do
       obj = klass.new
       obj.add 'projects', resource
-      obj.routes.length.should eql(1)
+      expect(obj.routes.length).to eql(1)
       route = obj.routes.first
-      route.should be_a(Restfulness::Route)
-      route.path.should eql(['projects'])
+      expect(route).to be_a(Restfulness::Route)
+      expect(route.path).to eql(['projects'])
     end
     it "should accept block as scope" do
       obj = klass.new
@@ -48,11 +48,11 @@ describe Restfulness::Router do
         add 'examples', SecondRouterResource
       end
       route = obj.routes.first
-      route.resource.should eql(SecondRouterResource)
-      route.path.should eql(['project', 'examples'])
+      expect(route.resource).to eql(SecondRouterResource)
+      expect(route.path).to eql(['project', 'examples'])
       route = obj.routes.last
-      route.resource.should eql(RouterResource)
-      route.path.should eql(['project'])
+      expect(route.resource).to eql(RouterResource)
+      expect(route.path).to eql(['project'])
     end
   end
 
@@ -63,8 +63,8 @@ describe Restfulness::Router do
       obj.scope 'api' do
         subscope = current_scope
       end
-      subscope.should eql(['api'])
-      obj.current_scope.should eql([])
+      expect(subscope).to eql(['api'])
+      expect(obj.current_scope).to eql([])
     end 
 
     it "should add scope properties to add call" do
@@ -74,7 +74,7 @@ describe Restfulness::Router do
         add 'projects', res
       end
       route = obj.routes.first
-      route.path.should eql(['api', 'projects'])
+      expect(route.path).to eql(['api', 'projects'])
     end
 
     it "should allow for scopes within scopes" do
@@ -89,11 +89,11 @@ describe Restfulness::Router do
         end
         subscope = current_scope
       end
-      subsubscope.should eql(['api', 'projects'])
-      subscope.should eql(['api'])
-      obj.current_scope.should eql([])
+      expect(subsubscope).to eql(['api', 'projects'])
+      expect(subscope).to eql(['api'])
+      expect(obj.current_scope).to eql([])
       route = obj.routes.first
-      route.path.should eql(['api', 'projects', 'active'])
+      expect(route.path).to eql(['api', 'projects', 'active'])
     end
   end
 
@@ -110,47 +110,47 @@ describe Restfulness::Router do
 
     it "should determine the route for a simple path" do
       route = obj.route_for("/projects")
-      route.should_not be_nil
-      route.path.should eql(['projects'])
+      expect(route).not_to be_nil
+      expect(route.path).to eql(['projects'])
     end
 
     it "should determine the route for a simple path with id" do
       route = obj.route_for("/projects")
-      route.should_not be_nil
-      route.path.should eql(['projects'])
+      expect(route).not_to be_nil
+      expect(route.path).to eql(['projects'])
     end
 
     it "should determine the route for a simple path with id and end /" do
       route = obj.route_for("/projects/12345/")
-      route.should_not be_nil
-      route.path.should eql(['projects'])
+      expect(route).not_to be_nil
+      expect(route.path).to eql(['projects'])
     end
 
     it "should determine the route for a simple path with end /" do
       route = obj.route_for("/projects/")
-      route.should_not be_nil
-      route.path.should eql(['projects'])
+      expect(route).not_to be_nil
+      expect(route.path).to eql(['projects'])
     end
 
     it "should determine route for more complex path" do
       route = obj.route_for("/project/1235/status/1234")
-      route.should_not be_nil
-      route.path.should eql(['project', :project_id, 'status'])
+      expect(route).not_to be_nil
+      expect(route.path).to eql(['project', :project_id, 'status'])
     end
 
     it "should return nil if not matched" do
       route = obj.route_for("/projects/1235/statuses/")
-      route.should be_nil
+      expect(route).to be_nil
     end
 
     it "should match empty path" do
       route = obj.route_for("/")
-      route.path.should eql([])
+      expect(route.path).to eql([])
     end
 
     it "should match path with single parameter" do
       route = obj.route_for("/something")
-      route.path.should eql([:page])
+      expect(route.path).to eql([:page])
     end
   end