restfulness 0.1.0

data/spec/unit/dispatcher_spec.rb

@@ -0,0 +1,14 @@
+
+require 'spec_helper'
+
+describe Restfulness::Dispatcher do
+
+  describe "#initialize" do
+    it "should assign app variable" do
+      obj = Restfulness::Dispatcher.new(:foo)
+      obj.app.should eql(:foo)
+    end
+  end
+
+
+end

data/spec/unit/dispatchers/rack_spec.rb

@@ -0,0 +1,34 @@
+
+require 'spec_helper'
+
+describe Restfulness::Dispatchers::Rack do
+
+  let :klass do
+    Restfulness::Dispatchers::Rack
+  end
+
+  let :app do
+    Class.new(Restfulness::Application).new
+  end
+
+  let :obj do
+    klass.new(app)
+  end
+
+  let :env do
+    {
+      'REQUEST_METHOD' => 'GET',
+      'SCRIPT_NAME'    => 'projects',
+      'PATH_INFO'      => 'projects',
+      'QUERY_STRING'   => '',
+      'SERVER_NAME'    => 'localhost',
+      'SERVER_PORT'    => '3000',
+      'HTTP_CONTENT_TYPE' => 'application/json'
+    }
+  end
+
+  describe "#" do
+
+  end
+
+end

data/spec/unit/exceptions_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Restfulness::HTTPException do
+
+  describe "#initialize" do
+    it "should assign variables" do
+      obj = Restfulness::HTTPException.new(200, "payload", :message => 'foo', :headers => {})
+      obj.code.should eql(200)
+      obj.payload.should eql("payload")
+      obj.message.should eql('foo')
+      obj.headers.should eql({})
+    end
+
+    it "should use status code for message if none provided" do
+      obj = Restfulness::HTTPException.new(200, "payload")
+      obj.message.should eql('OK')
+    end
+  end
+
+
+end

data/spec/unit/path_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Restfulness::Path do
+
+  class PathResource < Restfulness::Resource
+  end
+
+  let :klass do
+    Restfulness::Path
+  end
+  let :route_class do
+    Restfulness::Route
+  end
+  let :resource_class do
+    PathResource
+  end
+  let :simple_route do
+    route_class.new('project', resource_class)
+  end
+  let :complex_route do
+    route_class.new('project', :project_id, 'status', resource_class)
+  end
+
+  describe "#initialize" do
+    
+    it "should assign route" do
+      obj = klass.new(simple_route, '/project')
+      obj.route.should eql(simple_route)
+    end
+
+    context "simple paths" do
+      it "should prepare basic path" do
+        obj = klass.new(simple_route, '/project')
+        obj.components.should eql(['project'])
+        obj.params[:id].should be_nil
+      end
+
+      it "should prepare irregular path components" do
+        obj = klass.new(simple_route, '/project/')
+        obj.components.should eql(['project'])
+      end
+
+      it "should include id" do
+        obj = klass.new(simple_route, '/project/12345')
+        obj.components.should eql(['project', '12345'])
+        obj.params[:id].should eql('12345')
+      end
+    end
+
+
+    context "complex paths" do
+      it "should prepare path" do
+        obj = klass.new(complex_route, '/project/12345/status')
+        obj.components.should eql(['project', '12345', 'status'])
+        obj.params[:project_id].should eql('12345')
+      end
+
+      it "should handle end id" do
+        obj = klass.new(complex_route, '/project/12345/status/23456')
+        obj.components.should eql(['project', '12345', 'status', '23456'])
+        obj.params[:project_id].should eql('12345')
+        obj.params[:id].should eql('23456')
+      end
+    end
+  end
+
+  describe "#to_s" do
+    it "should provide simple string" do
+      obj = klass.new(complex_route, '/project/12345/status/23456')
+      obj.to_s.should eql('/project/12345/status/23456')
+    end
+  end
+
+  describe "#[]" do
+    let :obj do
+      obj = klass.new(complex_route, '/project/12345/status/23456')
+    end
+    it "should grant access to components by index" do
+      obj[0].should eql('project')
+      obj[1].should eql('12345')
+      obj[2].should eql('status')
+      obj[3].should eql('23456')
+      obj[4].should be_nil
+    end
+    it "should grant access to path parameters by symbol" do
+      obj[:project_id].should eql('12345')
+      obj[:id].should eql('23456')
+    end
+  end
+
+end

data/spec/unit/request_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Restfulness::Request do
+
+  let :app do
+    Class.new(Restfulness::Application) do
+      routes do
+        # nothing
+      end
+    end
+  end
+  
+  let :klass do
+    Restfulness::Request
+  end
+
+  let :obj do
+    klass.new(app)
+  end
+
+  class RequestResource < Restfulness::Resource
+  end
+  let :resource do
+    RequestResource
+  end
+    
+  
+  describe "#initialize" do
+    it "should prepare basic objects" do
+      obj.action.should be_nil
+      obj.headers.should eql({})
+      obj.body.should be_nil
+    end
+  end
+
+  describe "#uri=" do
+    it "should convert URL into URI" do
+      obj.uri = "https://example.com/project/12345"
+      obj.uri.path.should eql("/project/12345")
+    end
+  end
+
+  describe "#path" do
+    it "should be nil if there is no route" do
+      obj.stub(:route).and_return(nil)
+      obj.path.should be_nil
+    end
+
+    context "with route" do
+      let :path do
+        obj.uri = "https://example.com/project/12345"
+        route = Restfulness::Route.new('project', resource)
+        obj.stub(:route).and_return(route)
+        obj.path
+      end
+
+      it "should build path" do
+        path.to_s.should eql('/project/12345')
+      end
+
+      it "should re-use same path object" do
+        path.object_id.should eql(obj.path.object_id)
+      end
+    end
+  end
+
+  describe "#route" do
+    it "should ask the router for a route" do
+      obj.uri = "https://example.com/project/12345"
+      route = double(:Route)
+      app.router.should_receive(:route_for).with(obj.uri.path).and_return(route)
+      obj.route.should eql(route)
+    end
+  end
+
+  describe "#query" do
+    it "should parse uri with query" do
+      obj.uri = "https://example.com/project/12345?foo=bar&test=23"
+      obj.query.should be_a(HashWithIndifferentAccess)
+      obj.query[:foo].should eql('bar')
+      obj.query[:test].to_i.should eql(23)
+    end
+
+    it "should handle uri with empty query" do
+      obj.uri = "https://example.com/project/12345"
+      obj.query.should be_empty
+    end
+
+    it "should handle complex query items" do
+      obj.uri = "https://example.com/project/12345?foo[]=bar&foo[]=bar2&hash[a]=b&hash[b]=c"
+      obj.query[:foo].should eql(['bar', 'bar2'])
+      obj.query[:hash].should be_a(HashWithIndifferentAccess)
+      obj.query[:hash][:a].should eql('b')
+    end
+  end
+
+  describe "#params" do
+    it "should not return anything for empty body" do
+      obj.stub(:body).and_return(nil)
+      obj.params.should be_nil
+    end
+    it "should raise 406 error if no content type" do
+      obj.headers[:content_type] = nil
+      obj.body = "{\"foo\":\"bar\"}"
+      expect {
+        obj.params
+      }.to raise_error(Restfulness::HTTPException, "Not Acceptable")
+    end
+    it "should decode a JSON body" do
+      obj.headers[:content_type] = "application/json"
+      obj.body = "{\"foo\":\"bar\"}"
+      obj.params['foo'].should eql('bar')
+    end
+  end
+
+  describe "method helpers" do
+    it "should respond to method questions" do
+      [:get?, :post?, :put?, :delete?, :head?, :options?].each do |q|
+        obj.should respond_to(q)
+      end
+    end
+    it "should suggest type of method" do
+      obj.action = :get
+      obj.get?.should be_true
+      obj.post?.should be_false
+    end
+  end
+
+end

data/spec/unit/resource_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+describe Restfulness::Resource do
+
+  class GetResource < Restfulness::Resource
+    def get
+      'result'
+    end
+  end
+
+  class GetPostResource < Restfulness::Resource
+    def get
+      'result'
+    end
+    def post
+      'post'
+    end
+  end
+
+  let :app do
+    Class.new(Restfulness::Application) do
+      routes do
+        # empty
+      end
+    end
+  end
+  let :request do
+    Restfulness::Request.new(app)
+  end
+  let :response do
+    Restfulness::Response.new(request)
+  end
+
+  describe "#initialize" do
+    let :resource do
+      GetResource
+    end
+    it "should assign request and response" do
+      obj = resource.new(request, response)
+      obj.request.should eql(request)
+      obj.response.should eql(response)
+    end
+  end
+
+  describe "#options" do
+    let :resource do
+      GetPostResource
+    end
+
+    it "should return list of supported methods" do
+      obj = resource.new(request, response)
+      obj.options.should be_nil
+      response.headers['Allow'].should eql('GET, POST, OPTIONS')
+    end
+  end
+
+  describe "#call" do
+    let :resource do
+      GetResource
+    end
+    it "should perform action" do
+      request.action = :get
+      obj = resource.new(request, response)
+      obj.should_receive(:get).and_return('res')
+      obj.call.should eql('res')
+    end
+
+  end
+
+  describe "#method_allowed?" do
+    let :resource do
+      GetPostResource
+    end
+
+    it "should be true on valid method" do
+      request.action = :get
+      obj = resource.new(request, response)
+      obj.method_allowed?.should be_true
+    end
+
+    it "should be false on invalid method" do
+      request.action = :put
+      obj = resource.new(request, response)
+      obj.method_allowed?.should be_false
+    end
+  end
+
+  describe "basic callback responses" do
+    let :resource do
+      GetPostResource
+    end
+
+    let :obj do
+      request.action = :get
+      obj = resource.new(request, response)
+    end
+
+    it "should all be true for questions" do
+      obj.exists?.should be_true
+      obj.authorized?.should be_true
+      obj.allowed?.should be_true
+    end
+
+    it "should be nil for values" do
+      obj.last_modified.should be_nil
+      obj.etag.should be_nil
+    end
+  end
+
+  describe "#check_callbacks" do
+    let :resource do
+      Class.new(GetPostResource) do
+        def head; nil; end
+        def put; nil; end
+        def delete; nil; end
+      end
+    end
+
+    let :obj do
+      request.action = :get
+      obj = resource.new(request, response)
+    end
+
+    it "should all be good by default" do
+      expect {
+        obj.check_callbacks
+      }.to_not raise_error
+    end
+
+    it "should raise error on invalid method" do
+      obj.stub(:method_allowed?).and_return(false)
+      expect {
+        obj.check_callbacks
+      }.to raise_error(Restfulness::HTTPException, "Method Not Allowed")
+    end
+
+    [:head, :get, :put, :delete].each do |action|
+      it "should raise error when not exists for #{action.to_s.upcase}" do
+        request.action = action
+        obj.stub(:exists?).and_return(false)
+        expect {
+          obj.check_callbacks
+        }.to raise_error(Restfulness::HTTPException, "Resource Not Found")
+      end
+    end
+
+    [:post].each do |action|
+      it "should not check exists? for #{action.to_s.upcase}" do
+        obj.request.action = action
+        obj.should_not_receive(:exists?)
+        obj.check_callbacks
+      end
+    end
+
+    it "should raise error when not authorized" do
+      obj.stub(:authorized?).and_return(false)
+      expect {
+        obj.check_callbacks
+      }.to raise_error(Restfulness::HTTPException, "Unauthorized")
+    end
+
+    it "should raise error when not allowed" do
+      obj.stub(:allowed?).and_return(false)
+      expect {
+        obj.check_callbacks
+      }.to raise_error(Restfulness::HTTPException, "Forbidden")
+    end
+
+    describe "with etag" do
+      it "should raise error when equal" do
+        obj.stub(:etag).and_return('sometag')
+        request.headers[:if_none_match] = 'sometag'
+        expect {
+          obj.check_callbacks
+        }.to raise_error(Restfulness::HTTPException, "Not Modified")
+      end
+
+      it "should continue if not equal" do
+        obj.stub(:etag).and_return('sometag')
+        request.headers[:if_none_match] = 'someoldtag'
+        expect {
+          obj.check_callbacks
+        }.to_not raise_error
+      end
+      
+      it "should not be called unless action is :get or :head" do
+        obj.should_not_receive(:etag)
+        request.headers[:if_none_match] = 'sometag'
+        [:post, :put, :delete].each do |action|
+          request.action = action
+          obj.check_callbacks
+        end
+      end
+    end
+
+    describe "with if modified" do
+      it "should raise error when equal" do
+        time = Time.now
+        obj.stub(:last_modified).and_return(time)
+        request.headers[:if_modified_since] = time.to_s
+        expect {
+          obj.check_callbacks
+        }.to raise_error(Restfulness::HTTPException, "Not Modified")
+      end
+
+      it "should continue if not equal" do
+        time = Time.now
+        obj.stub(:last_modified).and_return(time)
+        request.headers[:if_modified_since] = (time - 60).to_s
+        expect {
+          obj.check_callbacks
+        }.to_not raise_error
+      end
+
+      it "should not be called unless action is :get or :head" do
+        obj.should_not_receive(:last_modified)
+        request.headers[:if_modified_since] = 'somedate'
+        [:post, :put, :delete].each do |action|
+          request.action = action
+          obj.check_callbacks
+        end
+      end
+
+    end
+  end
+
+  describe "#error" do
+
+    class Get418Resource < Restfulness::Resource
+      def get
+        error(418, {})
+      end
+    end
+
+    it "should raise a new exception" do
+      klass = Get418Resource
+      obj = klass.new(request, response)
+      expect {
+        obj.get
+      }.to raise_error(Restfulness::HTTPException, "I'm A Teapot")
+    end
+
+  end
+
+end