rocketio 0.0.0 → 0.0.1

data/test/filters_test.rb

@@ -0,0 +1,177 @@
+require 'setup'
+
+spec :Filters do
+
+  context :composition do
+    it 'inherits filters from superclass' do
+      before, around, after = [], [], []
+      a = mock_controller {
+        before(:get) {before << :a}
+        around(:get) {|a| around << :a}
+        after(:get)  {after  << :a}
+        def get; end
+      }
+      b = mock_controller(a)
+      app(b)
+      get
+      assert([before, around, after]).all? {|a| a.include?(:a)}
+    end
+
+    it 'inherits filters explicitly' do
+      before, around, after = [], [], []
+      a = mock_controller {
+        before(:get) {before << :x}
+        around(:get) {|a| around << :x}
+        after(:get)  {after  << :x}
+        def get; end
+      }
+      b = mock_controller {
+        inherit :before, from: a
+        inherit :around, from: a
+        inherit :after, from: a
+      }
+      app(b)
+      get
+      assert([before, around, after]).all? {|a| a.include?(:x)}
+    end
+
+    test 'explicitly inherited filters overrides filters inherited from superclass' do
+      before, around, after = [], [], []
+      a = mock_controller {
+        before(:get) {before << :a}
+        around(:get) {|a| around << :a}
+        after(:get)  {after  << :a}
+        def get; end
+      }
+      b = mock_controller {
+        before(:get) {before << :b}
+        around(:get) {|a| around << :b}
+        after(:get)  {after  << :b}
+      }
+      c = mock_controller(a) {
+        inherit :before, from: b
+        inherit :around, from: b
+        inherit :after, from: b
+      }
+      app(c)
+      get
+      assert([before, around, after]).none? {|a| a.include?(:a)}
+      assert([before, around, after]).all? {|a| a.include?(:b)}
+    end
+
+    test 'explicitly inherited filters complements filters inherited from superclass' do
+      before_get, around_get, after_get = [], [], []
+      before_post, around_post, after_post = [], [], []
+      a = mock_controller {
+        before(:get) {before_get << :a}
+        around(:get) {|a| around_get << :a}
+        after(:get)  {after_get  << :a}
+      }
+      b = mock_controller {
+        before(:post) {before_post << :b}
+        around(:post) {|a| around_post << :b}
+        after(:post)  {after_post  << :b}
+      }
+      c = mock_controller(a) {
+        inherit :before, from: b
+        inherit :around, from: b
+        inherit :after, from: b
+      }
+      app(c)
+      get
+      assert([before_get, around_get, after_get]).all? {|a| a.include?(:a)}
+      post
+      assert([before_post, around_post, after_post]).all? {|a| a.include?(:b)}
+    end
+
+    it 'defined filters overrides filters inherited from superclass' do
+      before, around, after = [], [], []
+      a = mock_controller {
+        before(:get) {before << :a}
+        around(:get) {|a| around << :a}
+        after(:get)  {after  << :a}
+      }
+      b = mock_controller(a) {
+        before(:get) {before << :b}
+        after(:get)  {after  << :b}
+      }
+      app(b)
+      get
+      assert([before, after]).all? {|a| a == [:b]}
+      assert(around) == [:a]
+    end
+  end
+
+  it 'defines filters for all requested methods if called without arguments' do
+    before, around, after = [], [], []
+    app mock_controller {
+      before() {before << requested_method}
+      around() {|a| around << requested_method}
+      after()  {after  << requested_method}
+    }
+    filters = [before, around, after]
+
+    get
+    assert(filters).all? {|a| a.include?(:get)}
+
+    post
+    assert(filters).all? {|a| a.include?(:post)}
+
+    put
+    assert(filters).all? {|a| a.include?(:put)}
+
+    head
+    assert(filters).all? {|a| a.include?(:head)}
+
+    delete
+    assert(filters).all? {|a| a.include?(:delete)}
+  end
+
+  it 'defines filters only for given requested method(s)' do
+    before, around, after = [], [], []
+    app mock_controller {
+      before(:get) {before << requested_method}
+      around(:put, :post) {|a| around << requested_method}
+      after(:delete) {after << requested_method}
+      def delete; end
+    }
+    get
+    assert(before).include?(:get)
+    assert([around, after]).none? {|a| a.include?(:get)}
+
+    post
+    assert(around).include?(:post)
+    assert([before, after]).none? {|a| a.include?(:post)}
+
+    put
+    assert(around).include?(:put)
+    assert([before, after]).none? {|a| a.include?(:put)}
+
+    delete
+    assert(after).include?(:delete)
+    assert([before, around]).none? {|a| a.include?(:delete)}
+  end
+
+  it 'creates a void filter if called without a block' do
+    ctrl = mock_controller {
+      before(:get) {raise 'this should be overridden'}
+      before(:get)
+      def get; end
+    }.initialize_controller
+    app(ctrl)
+    expect(ctrl).to_receive(:__before_get__)
+    get
+  end
+
+  it 'it calls wildcard filters before specialized ones' do
+    buffer = []
+    app mock_controller {
+      # specialized filter, called only on GET requests
+      before(:get) {buffer << requested_method}
+      # wildcard filter, called on any requests
+      before {buffer << :*}
+    }
+    get
+    assert(buffer) == [:*, :get]
+  end
+end

data/test/halt_test.rb

@@ -0,0 +1,73 @@
+require 'setup'
+
+spec :HaltTest do
+  def halt_app *args, &block
+    app mock_controller {
+      define_method(:get) {
+        instance_exec(&block) if block
+        halt(*args)
+      }
+    }
+    get
+  end
+
+  it 'is halting using current response if no args given' do
+    halt_app {response.status = 222}
+    assert(last_response.status) == 222
+  end
+
+  it 'is setting status if a Integer arg given' do
+    halt_app 222
+    assert(last_response.status) == 222
+  end
+
+  it 'is updating headers if a Hash arg given' do
+    halt_app 'X' => 'Y'
+    assert(last_response['X']) == 'Y'
+  end
+
+  it 'is sets  body if a no Array no Rack::Response no Hash no Integer arg given' do
+    halt_app 'body'
+    assert(last_response.body) == 'body'
+  end
+
+  it 'accepts status and headers' do
+    halt_app 222, 'X' => 'Y'
+    assert(last_response.status) == 222
+    assert(last_response['X']) == 'Y'
+  end
+
+  it 'accepts status, headers and body as separate arguments' do
+    halt_app 222, 'body', 'X' => 'Y'
+    assert(last_response.status) == 222
+    assert(last_response['X']) == 'Y'
+    assert(last_response.body) == 'body'
+  end
+
+  it 'updates current response if an array given' do
+    halt_app [222, {'X' => 'Y'}, 'body']
+    assert(last_response.status) == 222
+    assert(last_response['X']) == 'Y'
+    assert(last_response.body) == 'body'
+  end
+
+  it 'ignores other arguments if an array given' do
+    halt_app [222, {'X' => 'Y'}, 'body'], 400, {'X' => 'Z'}, 'altbody'
+    assert(last_response.status) == 222
+    assert(last_response['X']) == 'Y'
+    assert(last_response.body) == 'body'
+  end
+
+  it 'returns a fatal error unless given array\'s second element is a Hash' do
+    halt_app [200, 'wrong headers', 'boby']
+    assert(last_response.status) == 500
+    assert(last_response.body) =~ /no implicit conversion of String into Hash/
+  end
+
+  it 'halts right away ignoring other arguments if a Rack::Response passed as first argument' do
+    halt_app Rack::Response.new('body', 222, {'X' => 'Y'}), 400, {'X' => 'Z'}, 'altbody'
+    assert(last_response.status) == 222
+    assert(last_response['X']) == 'Y'
+    assert(last_response.body) == 'body'
+  end
+end

data/test/helpers_test.rb

@@ -0,0 +1,171 @@
+require 'setup'
+
+spec :HelpersTest do
+
+  def status_app(code, &block)
+    code += 2 if [204, 205, 304].include? code
+    block ||= proc { }
+    app mock_controller {
+      define_method :get do
+        response.status = code
+        instance_eval(&block).inspect
+      end
+    }
+    get
+  end
+
+  context 'status' do
+    it 'sets the response status code' do
+      status_app 207
+      assert(last_response.status) == 207
+    end
+  end
+
+  context 'not_found?' do
+    it 'is true for status == 404' do
+      status_app(404) { not_found? }
+      assert(last_response.body) == 'true'
+    end
+
+    it 'is false for status gt 404' do
+      status_app(405) { not_found? }
+      assert(last_response.body) == 'false'
+    end
+
+    it 'is false for status lt 404' do
+      status_app(403) { not_found? }
+      assert(last_response.body) == 'false'
+    end
+  end
+
+  context 'informational?' do
+    it 'is true for 1xx status' do
+      status_app(100 + rand(100)) { informational? }
+      assert(last_response.body) == 'true'
+    end
+
+    it 'is false for status > 199' do
+      status_app(200 + rand(400)) { informational? }
+      assert(last_response.body) == 'false'
+    end
+  end
+
+  context 'success?' do
+    it 'is true for 2xx status' do
+      status_app(200 + rand(100)) { success? }
+      assert(last_response.body) == 'true'
+    end
+
+    it 'is false for status < 200' do
+      status_app(100 + rand(100)) { success? }
+      assert(last_response.body) == 'false'
+    end
+
+    it 'is false for status > 299' do
+      status_app(300 + rand(300)) { success? }
+      assert(last_response.body) == 'false'
+    end
+  end
+
+  context 'redirect?' do
+    it 'is true for 3xx status' do
+      status_app(300 + rand(100)) { redirect? }
+      assert(last_response.body) == 'true'
+    end
+
+    it 'is false for status < 300' do
+      status_app(200 + rand(100)) { redirect? }
+      assert(last_response.body) == 'false'
+    end
+
+    it 'is false for status > 399' do
+      status_app(400 + rand(200)) { redirect? }
+      assert(last_response.body) == 'false'
+    end
+  end
+
+  context 'client_error?' do
+    it 'is true for 4xx status' do
+      status_app(400 + rand(100)) { client_error? }
+      assert(last_response.body) == 'true'
+    end
+
+    it 'is false for status < 400' do
+      status_app(200 + rand(200)) { client_error? }
+      assert(last_response.body) == 'false'
+    end
+
+    it 'is false for status > 499' do
+      status_app(500 + rand(100)) { client_error? }
+      assert(last_response.body) == 'false'
+    end
+  end
+
+  context 'server_error?' do
+    it 'is true for 5xx status' do
+      status_app(500 + rand(100)) { server_error? }
+      assert(last_response.body) == 'true'
+    end
+
+    it 'is false for status < 500' do
+      status_app(200 + rand(300)) { server_error? }
+      assert(last_response.body) == 'false'
+    end
+  end
+
+  context 'body' do
+    it 'takes a block for deferred body generation' do
+      app mock_controller {
+        define_method(:get) { response.body = -> { 'Hello World' } }
+      }
+
+      get
+      assert(last_response.body) == 'Hello World'
+    end
+
+    it 'takes a String, Array, or other object responding to #each' do
+      app mock_controller {
+        define_method(:get) { response.body = 'Hello World' }
+      }
+
+      get
+      assert(last_response.body) == 'Hello World'
+    end
+  end
+
+  context 'headers' do
+    it 'sets headers on the response object when given a Hash' do
+      app mock_controller {
+        define_method(:get) {headers 'X-Foo' => 'bar', 'X-Baz' => 'bling'}
+      }
+
+      get
+      assert(last_response).ok?
+      assert(last_response['X-Foo']) == 'bar'
+      assert(last_response['X-Baz']) == 'bling'
+    end
+
+    it 'returns the response headers hash when no hash provided' do
+      app mock_controller {
+        define_method(:get) {headers['X-Foo'] = 'bar'}
+      }
+
+      get
+      assert(last_response).ok?
+      assert(last_response['X-Foo']) == 'bar'
+    end
+  end
+
+  context 'back' do
+    it "makes redirecting back pretty" do
+      app mock_controller('/foo') {
+        def get; redirect back end
+      }
+
+      env['HTTP_REFERER'] = 'http://github.com'
+      get '/foo'
+      assert(last_response).redirect?
+      assert(last_response.location) == "http://github.com"
+    end
+  end
+end

data/test/middleware_test.rb

@@ -0,0 +1,57 @@
+require 'setup'
+
+spec :Middleware do
+
+  buff = []
+  ware = Class.new {
+    def initialize(*); yield end
+    def call(*); [200, {}, []] end
+  }
+  before { buff.clear }
+
+  it 'inherits middleware from superclass' do
+    a = mock_controller {
+      use(ware) {buff << :x}
+      use(ware) {buff << :y}
+    }
+    b = mock_controller(a) {
+      def get; end
+    }
+    app mock_app(b)
+    get
+    assert(buff) == [:y, :x]
+  end
+
+  it 'complements middleware inherited from superclass' do
+    a = mock_controller {
+      use(ware) {buff << 1}
+      use(ware) {buff << 2}
+    }
+    b = mock_controller {
+      use(ware) { buff << 3 }
+      inherit :middleware, from: a
+      def get; end
+    }
+    app mock_app(b)
+    get
+    assert(buff) == [3, 2, 1]
+  end
+
+  it 'uses `inherit` to complement middleware inherited from superclass' do
+    a = mock_controller {
+      use(ware) {buff << :x}
+      use(ware) {buff << :y}
+    }
+    b = mock_controller(a) {
+      use(ware) {buff << :z}
+      def get; end
+    }
+    c = mock_controller(a) {
+      inherit :middleware, from: b
+      def get; end
+    }
+    app mock_app(c)
+    get
+    assert(buff) == [:y, :x, :z]
+  end
+end