rocketio 0.0.0.pre.alpha → 0.0.0

data/test/filters_test.rb

@@ -1,177 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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