rocketio 0.0.0.pre.alpha → 0.0.0

data/test/redirect_test.rb

@@ -1,135 +0,0 @@
-# Copyright (c) 2007, 2008, 2009 Blake Mizerany
-# Copyright (c) 2010, 2011, 2012, 2013, 2014 Konstantin Haase
-# Copyright (c) 2015 Slee Woo
-#
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation
-# files (the "Software"), to deal in the Software without
-# restriction, including without limitation the rights to use,
-# copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following
-# conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-# OTHER DEALINGS IN THE SOFTWARE.
-
-require 'setup'
-
-spec :Redirect do
-  before do
-    app mock_controller {
-      define_method(:get) { redirect '/foo' }
-      define_method(:post) { redirect '/foo' }
-    }
-    env.clear
-  end
-
-  it 'uses a 302 by default' do
-    get
-    assert(last_response.status) == 302
-    assert(last_response.body) == ''
-    assert(last_response['Location']) == 'http://rack.radar/foo'
-  end
-
-  it 'uses 301 for permanent redirects' do
-    app mock_controller {
-      define_method(:get) { permanent_redirect '/foo' }
-    }
-
-    get
-    assert(last_response.status) == 301
-    assert(last_response.body) == ''
-    assert(last_response['Location']) == 'http://rack.radar/foo'
-  end
-
-  it 'redirects back to request.referer when passed back' do
-    app mock_controller(:try_redirect) {
-      define_method(:get) { redirect back }
-    }
-
-    env['HTTP_REFERER'] = '/foo'
-    get '/try_redirect'
-    assert(last_response.status) == 302
-    assert(last_response['Location']) == 'http://rack.radar/foo'
-  end
-
-  it 'redirects using a non-standard HTTP port' do
-    env['HTTP_HOST'] = nil
-    env['SERVER_PORT'] = '81'
-    get
-    assert(last_response['Location']) == 'http://rack.radar:81/foo'
-  end
-
-  it 'redirects using a non-standard HTTPS port' do
-    env['HTTP_HOST'] = nil
-    env['SERVER_PORT'] = '444'
-    get
-    assert(last_response['Location']) == 'http://rack.radar:444/foo'
-  end
-
-  it 'uses 303 for post requests if request is HTTP 1.1' do
-    env['HTTP_VERSION'] = 'HTTP/1.1'
-    post
-    assert(last_response.status) == 303
-    assert(last_response.body) == ''
-    assert(last_response['Location']) == 'http://rack.radar/foo'
-  end
-
-  it 'uses 302 for post requests if request is HTTP 1.0' do
-    env['HTTP_VERSION'] = 'HTTP/1.0'
-    post
-    assert(last_response.status) == 302
-    assert(last_response.body) == ''
-    assert(last_response['Location']) == 'http://rack.radar/foo'
-  end
-
-  it 'works behind a reverse proxy' do
-    env['HTTP_X_FORWARDED_HOST'] = 'example.com'
-    env['SERVER_PORT'] = '8080'
-    get
-    assert(last_response['Location']) == 'http://example.com/foo'
-  end
-
-  it 'accepts absolute URIs' do
-    app mock_controller {
-      define_method(:get) {redirect 'http://google.com'}
-    }
-
-    get
-    assert(last_response.status) == 302
-    assert(last_response.body) == ''
-    assert(last_response['Location']) == 'http://google.com'
-  end
-
-  it 'accepts absolute URIs with a different schema' do
-    app mock_controller {
-      define_method(:get) {redirect 'mailto:jsmith@example.com'}
-    }
-
-    get
-    assert(last_response.status) == 302
-    assert(last_response.body) == ''
-    assert(last_response['Location']) == 'mailto:jsmith@example.com'
-  end
-
-  it 'accepts a URI object instead of a String' do
-    app mock_controller {
-      define_method(:get) {redirect URI.parse('http://sinatrarb.com')}
-    }
-
-    get
-    assert(last_response.status) == 302
-    assert(last_response.body) == ''
-    assert(last_response['Location']) == 'http://sinatrarb.com'
-  end
-end

data/test/render/engine_test.rb

@@ -1,71 +0,0 @@
-require 'setup'
-
-spec :engine do
-  it 'inherits engine from superclass' do
-    a = mock_controller {
-      engine :Slim
-    }
-    b = mock_controller(a) {
-    }
-    assert(b.initialize_controller.engine) == [:SlimTemplate, []]
-  end
-
-  it 'overrides engine inherited from superclass' do
-    a = mock_controller {
-      engine :Slim
-    }
-    b = mock_controller(a) {
-      engine :Turbo
-    }
-    assert(b.initialize_controller.engine) == [:TurboTemplate, []]
-  end
-
-  it 'can use include to override engine inherited from superclass' do
-    a = mock_controller {
-      engine :Slim
-    }
-    b = mock_controller(a) {
-      engine :Turbo
-    }
-    c = mock_controller(a) {
-      inherit :engine, from: b
-    }
-    assert(c.initialize_controller.engine) == [:TurboTemplate, []]
-  end
-
-  it 'uses a block (that runs at instance level) to define engine' do
-    app mock_controller {
-      engine {@x = 'x'; :Slim}
-      def get; engine[0].to_s + @x end
-    }
-    get
-    assert(last_response.body) == 'SlimTemplatex'
-  end
-
-  it 'can accept engine options when a block used' do
-    c = mock_controller {
-      engine {[:Slim, {pretty_print: true}]}
-    }
-    e,o = c.allocate.engine
-    assert(e) == :SlimTemplate
-    assert(o) == [{pretty_print: true}]
-  end
-
-  it 'uses inherited engine if given block returns no engine' do
-    a = mock_controller {
-      engine :Slim
-    }
-    b = mock_controller(a) {
-      engine {
-        :ERB if env['IAMABOT']
-      }
-      def get; engine[0].to_s end
-    }
-    app b
-    get
-    assert(last_response.body) == 'SlimTemplate'
-    env['IAMABOT'] = true
-    get
-    assert(last_response.body) == 'ERBTemplate'
-  end
-end

data/test/render/get.erb

@@ -1 +0,0 @@
-<%= url %>

data/test/render/items.erb

@@ -1 +0,0 @@
-items

data/test/render/layout.erb

@@ -1 +0,0 @@
-=<%= yield %>=

data/test/render/layout_test.rb

@@ -1,104 +0,0 @@
-require 'setup'
-
-spec :Views do
-  context :layouts do
-    it 'inherits layout from superclass' do
-      a = mock_controller {
-        layout :master
-      }
-      b = mock_controller(a) {
-      }
-      assert(b.initialize_controller.layout) == :master
-    end
-
-    it 'overrides layout inherited from superclass' do
-      a = mock_controller {
-        layout :master
-      }
-      b = mock_controller(a) {
-        layout :baster
-      }
-      assert(b.initialize_controller.layout) == :baster
-    end
-
-    it 'can use `inherit` to override layout inherited from superclass' do
-      a = mock_controller {
-        layout :master
-      }
-      b = mock_controller(a) {
-        layout :baster
-      }
-      c = mock_controller(a) {
-        inherit :layout, from: b
-      }
-      assert(c.initialize_controller.layout) == :baster
-    end
-
-    it 'renders without layout if no default layout set' do
-      app mock_controller {
-        def get; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('/')
-    end
-
-    it 'renders without layout if default layout set to false' do
-      app mock_controller {
-        layout false
-        def get; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('/')
-    end
-
-    it 'renders without layout if layout option set to nil or false' do
-      app mock_controller {
-        layout :layout
-        def var; @var end
-        def get;  render(layout: nil); end
-        def post; @var = 'x'; render(layout: false); end
-        def put;  @var = 'y'; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('/')
-      post
-      assert(last_response).is_ok_with_body('x')
-      put
-      assert(last_response).is_ok_with_body("=y=\n")
-    end
-
-    it 'renders with a defined layout' do
-      app mock_controller {
-        define_layout(:master) {'=<%= yield %>='}
-        layout :master
-        def get; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('=/=')
-    end
-
-    it 'prefers defined layouts over files' do
-      app mock_controller {
-        define_layout(:layout) {'-<%= yield %>-'}
-        layout :layout
-        def get; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('-/-')
-    end
-
-    it 'prefers explicit layouts over implicit ones' do
-      app mock_controller {
-        define_layout(:x) {'x<%= yield %>'}
-        define_layout(:y) {'y<%= yield %>'}
-        layout :x
-        def get; render {''}; end
-        def post; render(layout: :y) {''}; end
-      }
-      get
-      assert(last_response).is_ok_with_body('x')
-      post
-      assert(last_response).is_ok_with_body('y')
-    end
-  end
-end

data/test/render/layouts/master.erb

@@ -1 +0,0 @@
-outside <%= yield %> layout

data/test/render/layouts_test.rb

@@ -1,145 +0,0 @@
-require 'setup'
-
-spec :layouts do
-  context :compositing do
-    it 'inherits layouts from superclass' do
-      a = mock_controller {
-        define_layout(:a) {'a'}
-      }
-      b = mock_controller(a) {
-      }.initialize_controller
-      assert(b.__send__ b.layouts[:a]) == 'a'
-    end
-
-    it 'complements layouts inherited from superclass' do
-      a = mock_controller {
-        define_layout(:a) {'a'}
-      }
-      b = mock_controller(a) {
-        define_layout(:b) {'b'}
-      }.initialize_controller
-      assert(b.__send__ b.layouts[:a]) == 'a'
-      assert(b.__send__ b.layouts[:b]) == 'b'
-    end
-
-    it 'overrides layouts inherited from superclass' do
-      a = mock_controller {
-        define_layout(:x) {'a'}
-      }
-      b = mock_controller(a) {
-        define_layout(:x) {'b'}
-      }.initialize_controller
-      assert(b.__send__ b.layouts[:x]) == 'b'
-    end
-
-    test '`inherit` overrides layouts inherited from superclass' do
-      a = mock_controller {
-        define_layout(:x) {'a'}
-      }
-      b = mock_controller(a) {
-        define_layout(:x) {'b'}
-      }
-      c = mock_controller(a) {
-        inherit :layouts, from: b
-      }.initialize_controller
-      assert(c.__send__ c.layouts[:x]) == 'b'
-    end
-
-    test '`inherit` complements layouts inherited from superclass' do
-      a = mock_controller {
-        define_layout(:a) {'a'}
-      }
-      b = mock_controller(a) {
-        define_layout(:b) {'b'}
-      }
-      c = mock_controller(a) {
-        inherit :layouts, from: b
-      }.initialize_controller
-      assert(c.__send__ c.layouts[:a]) == 'a'
-      assert(c.__send__ c.layouts[:b]) == 'b'
-    end
-
-    test '`inherit` overrides defined layouts' do
-      a = mock_controller {
-        define_layout(:x) {'a'}
-      }
-      b = mock_controller {
-        define_layout(:x) {'b'}
-        inherit :layouts, from: a
-      }.initialize_controller
-      assert(b.__send__ b.layouts[:x]) == 'a'
-    end
-
-    test '`inherit` complements defined layouts' do
-      a = mock_controller {
-        define_layout(:a) {'a'}
-      }
-      b = mock_controller {
-        define_layout(:b) {'b'}
-        inherit :layouts, from: a
-      }.initialize_controller
-      assert(b.__send__ b.layouts[:a]) == 'a'
-      assert(b.__send__ b.layouts[:b]) == 'b'
-    end
-
-    it 'overrides layouts inherited via `inherit`' do
-      a = mock_controller {
-        define_layout(:x) {'a'}
-      }
-      b = mock_controller {
-        inherit :layouts, from: a
-        define_layout(:x) {'b'}
-      }.initialize_controller
-      assert(b.__send__ b.layouts[:x]) == 'b'
-    end
-  end
-
-  context :rendering do
-    it 'uses a file with same name if only name given' do
-      c = mock_controller {
-        define_layout :master
-      }.initialize_controller
-      assert(c.render_layout(:master) {'yo'}) == "master yo layout\n"
-    end
-
-    it 'raises a TemplateError if there is no file with same name' do
-      layout = rand.to_s
-      c = mock_controller {
-        define_layout layout
-      }.initialize_controller
-      assert {c.render_layout(layout) {}}.raise RocketIO::TemplateError
-    end
-
-    it 'uses given file - file resides in controller dirname' do
-      c = mock_controller {
-        define_layout :master, file: :layout
-      }.initialize_controller
-      assert(c.render_layout(:master) {'yo'}) == "=yo=\n"
-    end
-
-    it 'uses given file - file resides outside controller dirname' do
-      c = mock_controller {
-        define_layout :master, file: './layouts/master'
-      }.initialize_controller
-      assert(c.render_layout(:master) {'yo'}) == "outside yo layout\n"
-    end
-
-    it 'accepts a block for given file' do
-      c = mock_controller {
-        define_layout :master, file: -> {@outside ? './layouts/master' : :master}
-      }.initialize_controller
-      assert(c.render_layout(:master) {'yo'}) == "master yo layout\n"
-      c.instance_variable_set(:@outside, true)
-      assert(c.render_layout(:master) {'yo'}) == "outside yo layout\n"
-    end
-
-    it 'accepts a block and uses returned value as layout without searching for file' do
-      c = mock_controller {
-        define_layout(:master) {@admin ? ':<%= yield %>:' : '|<%= yield %>|'}
-      }.initialize_controller
-      assert(c.render_layout(:master) {'yo'}) == "|yo|"
-      c.instance_variable_set(:@admin, true)
-      assert(c.render_layout(:master) {'yo'}) == ":yo:"
-    end
-  end
-end