alf-rack 0.15.0

data/lib/alf/rack/response.rb

@@ -0,0 +1,74 @@
+module Alf
+  module Rack
+    # Specialization of `::Rack::Response` that automatically handles the
+    # encoding of tuples and relations according to HTTP_ACCEPT and available
+    # renderers.
+    #
+    # Example:
+    #
+    # ```
+    # require 'sinatra'
+    #
+    # use Alf::Rack::Connect{|cfg| ... }
+    # 
+    # get '/users' do
+    #   # get the connection (see Alf::Rack::Connect)
+    #   conn = ...
+    #
+    #   # The body relation/relvar will automatically be encoded to
+    #   # whatever format the user want among the available ones.
+    #   # The Content-Type response header is set accordingly.
+    #   Alf::Rack::Response.new(env){|r|
+    #     r.body = conn.query{ users }
+    #   }.finish
+    # end
+    # ```
+    #
+    class Response < ::Rack::Response
+
+      # Prepares a Response instance for a given Rack environment. Raises an
+      # AcceptError if no renderer can be found for the `HTTP_ACCEPT` header.
+      def initialize(env = {})
+        @renderer = Response.renderer!(env)
+        super([], 200, 'Content-Type' => @renderer.mime_type)
+      end
+
+      # Sets the body of the response to `payload`. The latter can be any
+      # object that Alf is able to render through the IO renderers (relations,
+      # relvars, tuples, etc.).
+      def body=(payload)
+        super(@renderer.new(payload))
+      end
+
+      class << self
+
+        # Returns the best renderer to use given HTTP_ACCEPT header and
+        # available Alf renderers.
+        def renderer(env)
+          media_type = ::Rack::Accept::MediaType.new(accept(env))
+          if best = media_type.best_of(supported_media_types)
+            Renderer.each.find{|(name,_,r)| r.mime_type == best }.last
+          end
+        end
+
+        # Returns the renderer to use for `env`. Raises an AcceptError if no
+        # renderer can be found.
+        def renderer!(env)
+          renderer(env) || raise(AcceptError, "Unsupported content type `#{accept(env)}`")
+        end
+
+        # Returns the HTTP_ACCEPT header of `env`. Defaults to 'application/json'
+        def accept(env)
+          env['HTTP_ACCEPT'] || 'application/json'
+        end
+
+        # Returns media types supported by the Renderer class.
+        def supported_media_types
+          Renderer.each.map{|(_,_,r)| r.mime_type}.compact.sort
+        end
+
+      end # class << self
+
+    end # class Response
+  end # module Rack
+end # module Alf

data/lib/alf/rack/version.rb

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

data/spec/config/test_database.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf
+  module Rack
+    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/config/test_viewpoint.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  module Rack
+    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/connect/test_principle.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+module Alf
+  module Rack
+    describe Connect, 'its Rack behavior' do
+      include ::Rack::Test::Methods
+
+      def mock_app(&bl)
+        Class.new(Sinatra::Base) do
+          set :environment, :test
+
+          disable :logging
+          disable :dump_errors
+          enable  :raise_errors
+          disable :show_exceptions
+
+          class_config = nil
+          use Alf::Rack::Connect do |cfg|
+            cfg.database = Path.dir
+            class_config  = cfg
+            bl.call(cfg) if bl
+          end
+
+          get '/check-config' do
+            check  = env[Alf::Rack::Connect::CONFIG_KEY].is_a?(Config)
+            check &= env[Alf::Rack::Connect::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/query/test_logical_behavior.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'alf/rack/query'
+module Alf
+  module Rack
+    describe Query, 'POST /logical' do
+      include ::Rack::Test::Methods
+
+      def mock_app(&bl)
+        sap = self.sap
+        ::Rack::Builder.new do
+          use Alf::Rack::Connect do |cfg|
+            cfg.database = sap
+          end
+          run Alf::Rack::Query.new
+        end
+      end
+
+      let(:app){ mock_app }
+
+      subject{ post("/logical", body, {"HTTP_ACCEPT" => "text/plain"}) }
+
+      before{ subject }
+
+      context 'when the body contains a valid query' do
+        let(:body){
+          "suppliers"
+        }
+
+        it 'succeeds' do
+          last_response.status.should eq(200)
+        end
+
+        it 'returns the expected plans' do
+          last_response.body.should =~ /origin/
+          last_response.body.should =~ /optimized/
+          last_response.body.should =~ /suppliers/
+        end
+      end
+    end
+  end
+end

data/spec/query/test_metadata_behavior.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'alf/rack/query'
+module Alf
+  module Rack
+    describe Query, 'POST /metadata' do
+      include ::Rack::Test::Methods
+
+      def mock_app(&bl)
+        sap = self.sap
+        ::Rack::Builder.new do
+          use Alf::Rack::Connect do |cfg|
+            cfg.database = sap
+          end
+          run Alf::Rack::Query.new
+        end
+      end
+
+      let(:app){ mock_app }
+
+      subject{ post("/metadata", body, {}) }
+
+      before{ subject }
+
+      context 'when the body contains a valid query' do
+        let(:body){
+          "suppliers"
+        }
+
+        it 'succeeds' do
+          last_response.status.should eq(200)
+        end
+
+        it 'correctly sets the content type' do
+          last_response.content_type.should eq('application/json')
+        end
+        
+        it 'returns the expected answer' do
+          body = ::JSON.parse(last_response.body)
+          body["heading"].should be_a(Array)
+          body["keys"].should be_a(Array)
+        end
+      end
+    end
+  end
+end

data/spec/query/test_root_behavior.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'alf/rack/query'
+require 'alf/lang/parser/safer'
+module Alf
+  module Rack
+    describe Query, 'POST /' do
+      include ::Rack::Test::Methods
+
+      def mock_app(&bl)
+        sap = self.sap
+        ::Rack::Builder.new do
+          use Alf::Rack::Connect do |cfg|
+            cfg.database = Alf::Database.new(sap, parser: Alf::Lang::Parser::Safer)
+          end
+          run Alf::Rack::Query.new
+        end
+      end
+
+      let(:app){ mock_app }
+
+      subject{ post(url, body, {}) }
+
+      before{ subject }
+
+      let(:url){ '/' }
+
+      context 'when the body contains a valid query' do
+        let(:body){
+          "restrict(suppliers, city: 'London')"
+        }
+
+        it 'succeeds' do
+          last_response.status.should eq(200)
+        end
+
+        it 'correctly sets the content type' do
+          last_response.content_type.should eq('application/json')
+        end
+
+        it 'returns the expected suppliers' do
+          body = ::JSON.parse(last_response.body)
+          body.should be_a(Array)
+          body.size.should eq(2)
+          body.map{|t| t["city"]}.uniq.should eq(["London"])
+          body.map{|t| t["sid"]}.should eq(["S1", "S4"])
+        end
+      end
+
+      context 'when the url is empty' do
+        let(:url){ '' }
+        let(:body){
+          "restrict(suppliers, city: 'London')"
+        }
+
+        it 'succeeds' do
+          last_response.status.should eq(200)
+        end
+      end
+
+      shared_examples_for 'an invalid client request' do
+        it 'leads to a 400 status' do
+          last_response.status.should eq(400)
+        end
+
+        it 'has the correct resuting content type' do
+          last_response.content_type.should eq('application/json')
+        end
+
+        it 'leads to an error message' do
+          body = ::JSON.parse(last_response.body)
+          body.should be_a(Hash)
+          body.keys.should eq(["error"])
+          body["error"].should =~ expected_message
+        end
+      end
+
+      context 'when the body contains an attack attempt' do
+        let(:body){
+          "`ls -lA`"
+        }
+        let(:expected_message){
+          /Forbidden/
+        }
+
+        it_should_behave_like "an invalid client request"
+      end
+
+      context 'when not a POST request' do
+        subject{ get("/") }
+
+        it 'fails with a 404' do
+          last_response.status.should eq(404)
+        end
+      end
+
+    end
+  end
+end

data/spec/response/class/test_renderer.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+module Alf
+  module Rack
+    describe Response, '.renderer' do
+
+      subject{ Response.renderer({"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/yaml' do
+        let(:accept){ "text/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
+end

data/spec/response/class/test_renderer_bang.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Alf
+  module Rack
+    describe Response, '.renderer!' do
+
+      subject{ Response.renderer!({"HTTP_ACCEPT" => accept}) }
+
+      context 'on supported' do
+        let(:accept){ "application/json" }
+
+        it{ should be(Renderer::JSON) }
+      end
+
+      context 'on unsupported' do
+        let(:accept){ "text/unknown" }
+
+        it 'raises a AcceptError' do
+          lambda{
+            subject
+          }.should raise_error(AcceptError, /Unsupported content type `text\/unknown`/)
+        end
+      end
+
+    end
+  end
+end