alf-rest 0.14.0

data/lib/alf/rest/version.rb

@@ -0,0 +1,16 @@
+module Alf
+  module Rest
+    module Version
+
+      MAJOR = 0
+      MINOR = 14
+      TINY  = 0
+
+      def self.to_s
+        [ MAJOR, MINOR, TINY ].join('.')
+      end
+
+    end
+    VERSION = Version.to_s
+  end
+end

data/lib/sinatra/alf-rest.rb

@@ -0,0 +1,73 @@
+require 'alf-rest'
+module Sinatra
+  module AlfRest
+
+    def rest_get(url, &bl)
+      get(url) do
+        Alf::Rest::Response.new(env){|r|
+          r.body = instance_exec(&bl)
+        }.finish
+      end
+    end
+
+    def rest_post(url, heading, &bl)
+      post(url) do
+        input   = Alf::Rest::Request.new(env, heading).to_tuple
+        result  = instance_exec(input, &bl)
+
+        Alf::Rest::Response.new(env){|r|
+          r.status = result.rack_status
+          r.body   = result.rack_body
+          if not(location_set?) and (loc = result.rack_location(request))
+            r["Location"] = loc
+          end
+        }.finish
+      end
+    end
+
+    def rest_put(url, heading, &bl)
+      put(url) do
+        input   = Alf::Rest::Request.new(env, heading).to_tuple
+        result  = instance_exec(input, &bl)
+
+        Alf::Rest::Response.new(env){|r|
+          r.status = result.rack_status
+          r.body   = result.rack_body
+          r["Location"] = request.path unless location_set?
+        }.finish
+      end
+    end
+
+    def rest_delete(url, heading, &bl)
+      delete(url) do
+        input  = Tuple[heading].coerce(params.select{|k| heading[k.to_sym]})
+        result = instance_exec(input, &bl)
+
+        Alf::Rest::Response.new(env){|r|
+          r.status = result.rack_status
+          r.body   = result.rack_body
+          if not(location_set?) and (loc = result.rack_location(request))
+            r["Location"] = loc
+          end
+        }.finish
+      end
+    end
+
+    def alf_rest
+      if block_given?
+        yield(settings.alf_configuration)
+      else
+        settings.alf_configuration
+      end
+    end
+
+    def self.registered(app)
+      config = Alf::Rest::Config.new
+      app.set :alf_configuration, config
+      app.use Alf::Rest::Middleware, config
+      app.helpers Alf::Rest::Helpers
+    end
+
+  end
+  register AlfRest
+end

data/spec/integration/sinatra/rest_get/test_accept.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+module Alf
+  module Rest
+    describe "rest_get", "Accept header" do
+      include Rack::Test::Methods
+
+      def app
+        mock_app do
+          rest_get '/suppliers' do
+            relvar{ suppliers }
+          end
+        end
+      end
+
+      def last_meta
+        [last_response.status, last_response.content_type]
+      end
+
+      it 'defaults to application/json when unspecified' do
+        #
+        get '/suppliers'
+        #
+        last_meta.should eq([200, "application/json"])
+        #
+        result = JSON.load(last_response.body)
+        result.should be_a(Array)
+        result.size.should eq(5)
+      end
+
+      it 'supports */* and fallbacks to application/json' do
+        #
+        header "Accept", "*/*"
+        get '/suppliers'
+        #
+        last_meta.should eq([200, "application/json"])
+        #
+        result = JSON.load(last_response.body)
+        result.should be_a(Array)
+        result.size.should eq(5)
+      end
+
+      it 'supports application/json' do
+        #
+        header "Accept", "application/json"
+        get '/suppliers'
+        #
+        last_meta.should eq([200, "application/json"])
+        #
+        result = JSON.load(last_response.body)
+        result.should be_a(Array)
+        result.size.should eq(5)
+      end
+
+      it 'supports text/csv' do
+        #
+        header "Accept", "text/csv"
+        get '/suppliers'
+        #
+        last_meta.should eq([200, "text/csv"])
+        #
+        last_response.body.should =~ /1,Smith,20,London/
+      end
+
+      it 'supports text/plain' do
+        #
+        header "Accept", "text/plain"
+        get '/suppliers'
+        #
+        last_meta.should eq([200, "text/plain"])
+        #
+        last_response.body.should =~ /\|\s+1\s+\|\s+Smith\s+\|/
+      end
+
+      it 'supports text/x-yaml' do
+        #
+        header "Accept", "text/x-yaml"
+        get '/suppliers'
+        #
+        last_meta.should eq([200, "text/x-yaml"])
+        #
+        last_response.body.should =~ /- :sid: 1/
+      end
+
+      it 'supports a complex specification' do
+        #
+        header "Accept", "application/*, text/*;q=0.8"
+        get '/suppliers'
+        #
+        last_meta.should eq([200, "application/json"])
+        #
+        result = JSON.load(last_response.body)
+        result.should be_a(Array)
+        result.size.should eq(5)
+      end
+
+    end
+  end
+end

data/spec/integration/spec_helper.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
+require 'alf-sequel'
+require 'sinatra/alf-rest'
+require 'rspec'
+require 'path'
+require 'rack/test'
+
+module Helpers
+
+  def mock_app(&bl)
+    Class.new(Sinatra::Base){
+      register Sinatra::AlfRest
+      alf_rest do |cfg|
+        cfg.database = Alf.database(Path.backfind('fixtures/sap.db'))
+      end
+      enable  :raise_errors
+      disable :show_exceptions
+      instance_eval(&bl)
+    }
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include Helpers
+  c.extend  Helpers
+end

data/spec/test_rest.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Alf
+  describe Rest do
+
+    it "should have a version number" do
+      Rest.const_defined?(:VERSION).should be_true
+    end
+
+  end
+end

data/spec/unit/config/test_database.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf
+  module Rest
+    describe Config, "database=" do
+
+      let(:config){ Config.new }
+
+      subject{ 
+        config.database = db
+        config.database
+      }
+
+      context 'with a Alf::Database' do
+        let(:db){ Alf.database(Path.dir) }
+
+        it{ should be_a(Alf::Database) }
+        it{ should be(db) }
+      end
+
+      context 'with an adapter' do
+        let(:db){ Path.dir }
+
+        it{ should be_a(Alf::Database) }
+      end
+
+    end
+  end
+end

data/spec/unit/config/test_viewpoint.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  module Rest
+    describe Config, "viewpoint=" do
+
+      let(:config){ Config.new }
+
+      subject{ config.viewpoint = Alf::Viewpoint::NATIVE }
+
+      it 'sets it on the connection options' do
+        subject
+        config.connection_options[:viewpoint].should be(Alf::Viewpoint::NATIVE)
+        config.viewpoint.should be(Alf::Viewpoint::NATIVE)
+      end
+
+    end
+  end
+end

data/spec/unit/ext/renderer/test_from_http_accept.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+module Alf
+  describe Renderer, "from_http_accept" do
+
+    subject{ Renderer.from_http_accept(accept) }
+
+    context 'application/json' do
+      let(:accept){ "application/json" }
+
+      it{ should be(Renderer::JSON) }
+    end
+
+    context 'text/plain' do
+      let(:accept){ "text/plain" }
+
+      it{ should be(Renderer::Text) }
+    end
+
+    context 'text/csv' do
+      let(:accept){ "text/csv" }
+
+      it{ should be(Renderer::CSV) }
+    end
+
+    context 'text/x-yaml' do
+      let(:accept){ "text/x-yaml" }
+
+      it{ should be(Renderer::YAML) }
+    end
+
+    context '*/*' do
+      let(:accept){ "*/*" }
+
+      it{ should be(Renderer::JSON) }
+    end
+
+    context 'text/unknown' do
+      let(:accept){ "text/unknown" }
+
+      it{ should be(nil) }
+    end
+
+    context 'a complex one' do
+      let(:accept){ "text/unknown, text/*;q=0.8, */*;q=0.5" }
+
+      it{ should be(Renderer::CSV) }
+    end
+
+  end
+end

data/spec/unit/ext/renderer/test_supported_media_types.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Alf
+  describe Renderer, "supported_media_types" do
+
+    subject{ Renderer.supported_media_types.sort }
+
+    it{ should eq(["application/json", "text/csv", "text/plain", "text/x-yaml"]) }
+
+  end
+end

data/spec/unit/middleware/test_behavior.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+module Alf
+  module Rest
+    describe Middleware, 'its Rack behavior' do
+      include Rack::Test::Methods
+
+      def mock_app(&bl)
+        Class.new(Sinatra::Base) do
+          set :environment, :test
+
+          disable :dump_errors
+          disable :logging
+          disable :dump_errors
+          enable :raise_errors
+          disable :show_exceptions
+
+          class_config = nil
+          use Alf::Rest do |cfg|
+            cfg.database = Alf::Database.new(Path.dir)
+            class_config  = cfg
+            bl.call(cfg) if bl
+          end
+
+          get '/check-config' do
+            check  = env[Rest::RACK_CONFIG_KEY].is_a?(Config)
+            check &= env[Rest::RACK_CONFIG_KEY] != class_config
+            check.to_s
+          end
+
+          get '/generate-error' do
+            raise "blah"
+          end
+        end
+      end
+
+      context 'on a default app' do
+        let(:app){ mock_app }
+
+        it 'sets a duplicata of the configuration' do
+          get '/check-config'
+          last_response.body.should eq("true")
+        end
+      end
+
+      context 'when an error occurs' do
+        let(:app){ mock_app }
+
+        it 'raises the Error outside the app' do
+          lambda{ get '/generate-error' }.should raise_error(/blah/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/request/test_to_relation.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Alf
+  module Rest
+    describe Request, "to_relation" do
+
+      let(:request){ Alf::Rest::Request.new(env, heading) }
+
+      let(:heading){ {status: Integer, city: String} }
+
+      subject{ request.to_relation }
+
+      context 'with application/x-www-form-urlencoded' do
+        let(:env)  { env_for("/foo", method: 'POST', params: tuple) }
+        let(:tuple){ {city: "London", status: "200"} }
+
+        it 'gets the iterated tuples from POST' do
+          subject.should eq(Relation(city: "London", status: 200))
+        end
+      end
+
+      context 'with a body conforming to Rack spec strictly' do
+        let(:env)  { json_post_env(tuple) }
+        let(:tuple){ {city: "London", status: "200"} }
+
+        before do
+          env['rack.input'] = Struct.new(:read, :rewind).new(env['rack.input'].read)
+        end
+
+        it 'gets the iterated tuples from POST' do
+          subject.should eq(Relation(city: "London", status: 200))
+        end
+      end
+
+      context 'with a JSON encoded body' do
+        let(:env){ json_post_env(tuples) }
+
+        context 'when the input matches exactly' do
+          let(:tuples){ [{city: "London", status: "200"}] }
+
+          it 'gets the expected relation' do
+            subject.should eq(Relation(status: 200, city: "London"))
+          end
+        end
+
+        context 'when a projection is needed' do
+          let(:tuples){ [{name: "Smith", status: "200"}] }
+
+          it 'gets the expected relation' do
+            subject.should eq(Relation(status: 200))
+          end
+        end
+      end
+
+    end
+  end
+end