rocketio 0.0.0 → 0.0.1

data/test/render/master.erb

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

data/test/render/post.erb

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

data/test/render/put.erb

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

data/test/render/render_test.rb

@@ -0,0 +1,101 @@
+require 'setup'
+
+spec :Views do
+  context :cache do
+    engine = Tilt::ERBTemplate
+    path = File.expand_path('../templates/a', __FILE__)
+    define_method(:file) {mock_controller(:a).initialize_controller.send(:find_template, path, 'get', engine)}
+    define_method(:read) {mock_controller(:a).initialize_controller.send(:read_template, file).__id__}
+    define_method(:compile) {|tpl| mock_controller(:a).initialize_controller.send(:compile_template, tpl, engine).__id__}
+
+    it 'resolves template path only once' do
+      cache_id = file.__id__
+      assert(file.__id__) == cache_id
+    end
+
+    it 'rereads templates only when template file modified' do
+      cache_id = read
+      assert(read) == cache_id
+      FileUtils.touch(file)
+      refute(read) == cache_id
+    end
+
+    it 'recompiles template only if it was modified' do
+      cache_id = compile('')
+      assert(compile('')) == cache_id
+      refute(compile('changed')) == cache_id
+    end
+  end
+
+  context :scope do
+    it 'uses controller instance for scope' do
+      app mock_controller {
+        before {@var = :val}
+        def post; render; end
+      }
+      post
+      assert(last_response).is_ok_with_body('val')
+    end
+    it 'uses custom scope' do
+      app mock_controller {
+        before {@var = :val}
+        def post
+          scope = Class.new {def initialize; @var = :vax; end}.new
+          render(scope: scope)
+        end
+      }
+      post
+      assert(last_response).is_ok_with_body('vax')
+    end
+  end
+
+  context :locals do
+    it 'makes :locals accessible via attributes' do
+      app mock_controller {
+        def put; render(locals: {var: :val}); end
+      }
+      put
+      assert(last_response).is_ok_with_body('val')
+    end
+  end
+
+  context 'implicit templates' do
+    it 'uses the folder controller resides in as default path' do
+      app controller = mock_controller(:a) {
+        def get; render end
+      }
+      get
+      assert(last_response).is_ok_with_body '/a'
+    end
+  end
+
+  context 'defined templates' do
+    it 'prefers defined templates over files' do
+      app mock_controller {
+        define_template(:get) {'x'}
+        def get; render end
+      }
+      get
+      assert(last_response).is_ok_with_body 'x'
+    end
+
+    it 'renders defined template with defined layout' do
+      app mock_controller {
+        define_template(:t) {'t'}
+        define_layout(:x) {'x<%= yield %>x'}
+        layout(:x)
+        def get; render(:t) end
+      }
+      get
+      assert(last_response).is_ok_with_body 'xtx'
+    end
+  end
+
+  it 'uses given block for template' do
+    app mock_controller {
+      def get; render {'x'} end
+    }
+    get
+    assert(last_response).is_ok_with_body 'x'
+  end
+end

data/test/render/setup.rb

@@ -0,0 +1,14 @@
+require 'test/setup'
+
+spec do
+  # overriding mock_controller cause when defining a controller
+  # caller used to set controller's dirname
+  # and we do not want to clobber test/ dir with template files
+  def mock_controller path = :/, superclass = nil, &block
+    path, superclass = :/, path if path.is_a?(Class)
+    controller = Class.new(superclass || RocketIO::Controller)
+    controller.map(path)
+    controller.class_exec(&block) if block
+    controller
+  end
+end

data/test/render/templates/a/get.erb

@@ -0,0 +1 @@
+hi

data/test/render/templates/master.erb

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

data/test/render/templates_test.rb

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

data/test/request_test.rb

@@ -0,0 +1,105 @@
+require 'setup'
+require 'stringio'
+
+# tests stolen from github.com/sinatra/sinatra
+# Copyright (c) 2007, 2008, 2009 Blake Mizerany
+# Copyright (c) 2010, 2011, 2012, 2013, 2014 Konstantin Haase
+# Copyright (c) 2015 Slee Woo
+
+spec RocketIO::Request do
+
+  it 'responds to #user_agent' do
+    request = RocketIO::Request.new({'HTTP_USER_AGENT' => 'Test'})
+    assert(request).respond_to?(:user_agent)
+    assert('Test') == request.user_agent
+  end
+
+  it 'parses POST params when Content-Type is form-dataish' do
+    request = RocketIO::Request.new(
+      'REQUEST_METHOD' => 'PUT',
+      'CONTENT_TYPE' => 'application/x-www-form-urlencoded',
+      'rack.input' => StringIO.new('foo=bar')
+    )
+    assert('bar') == request.params['foo']
+  end
+
+  it 'is secure when the url scheme is https' do
+    request = RocketIO::Request.new('rack.url_scheme' => 'https')
+    assert(request).secure?
+  end
+
+  it 'is not secure when the url scheme is http' do
+    request = RocketIO::Request.new('rack.url_scheme' => 'http')
+    refute(request).secure?
+  end
+
+  it 'respects X-Forwarded-Proto header for proxied SSL' do
+    request = RocketIO::Request.new('HTTP_X_FORWARDED_PROTO' => 'https')
+    assert(request).secure?
+  end
+
+  it 'is possible to marshal params' do
+    request = RocketIO::Request.new(
+      'REQUEST_METHOD' => 'PUT',
+      'CONTENT_TYPE' => 'application/x-www-form-urlencoded',
+      'rack.input' => StringIO.new('foo=bar')
+    )
+    dumped = Marshal.dump(request.params)
+    assert('bar') == Marshal.load(dumped)['foo']
+  end
+
+  it "exposes the preferred type's parameters" do
+    request = RocketIO::Request.new(
+      'HTTP_ACCEPT' => 'image/jpeg; compress=0.25'
+    )
+    assert({ 'compress' => '0.25' }) == request.preferred_type.params
+  end
+
+  it "makes accept types behave like strings" do
+    request = RocketIO::Request.new('HTTP_ACCEPT' => 'image/jpeg; compress=0.25')
+    assert(request).accept?('image/jpeg')
+    assert('image/jpeg') == request.preferred_type.to_s
+    assert('image/jpeg; compress=0.25') == request.preferred_type.to_s(true)
+    assert('image/jpeg') == request.preferred_type.to_str
+    assert('image') ==      request.preferred_type.split('/').first
+
+    String.instance_methods.each do |method|
+      next unless "".respond_to? method
+      assert(request.preferred_type).respond_to?(method)
+    end
+  end
+
+  it "accepts types when wildcards are requested" do
+    request = RocketIO::Request.new('HTTP_ACCEPT' => 'image/*')
+    assert(request).accept?('image/jpeg')
+  end
+
+  it "properly decodes MIME type parameters" do
+    request = RocketIO::Request.new(
+      'HTTP_ACCEPT' => 'image/jpeg;unquoted=0.25;quoted="0.25";chartest="\";,\x"'
+    )
+    expected = { 'unquoted' => '0.25', 'quoted' => '0.25', 'chartest' => '";,x' }
+    assert(expected) == request.preferred_type.params
+  end
+
+  it 'accepts */* when HTTP_ACCEPT is not present in the request' do
+    request = RocketIO::Request.new Hash.new
+    assert(1) == request.accept.size
+    assert(request).accept?('text/html')
+    assert('*/*') == request.preferred_type.to_s
+    assert('*/*') == request.preferred_type.to_s(true)
+  end
+
+  it 'accepts */* when HTTP_ACCEPT is blank in the request' do
+    request = RocketIO::Request.new 'HTTP_ACCEPT' => ''
+    assert(1) == request.accept.size
+    assert(request).accept?('text/html')
+    assert('*/*') == request.preferred_type.to_s
+    assert('*/*') == request.preferred_type.to_s(true)
+  end
+
+  it 'will not accept types not specified in HTTP_ACCEPT when HTTP_ACCEPT is provided' do
+    request = RocketIO::Request.new 'HTTP_ACCEPT' => 'application/json'
+    refute(request).accept?('text/html')
+  end
+end

data/test/response_test.rb

@@ -0,0 +1,119 @@
+# 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 RocketIO::Response do
+  before { @response = RocketIO::Response.new }
+
+  assert :identical_to? do |a,b|
+    a.to_enum(:each).to_a == b.to_enum(:each).to_a
+  end
+
+  it "initializes with 200 status code, empty body and nil content type" do
+    assert(@response.status) == 200
+    assert(@response['Content-Type']).nil?
+    assert(@response.body) == []
+  end
+
+  it 'uses case insensitive headers' do
+    @response['content-type'] = 'application/foo'
+    assert('application/foo') == @response['Content-Type']
+    assert('application/foo') == @response['CONTENT-TYPE']
+  end
+
+  it 'writes to body' do
+    @response.body = 'Hello'
+    @response.write ' World'
+    assert('Hello World') == @response.body.join
+  end
+
+  [204, 304].each do |status_code|
+    it "removes the Content-Type header and body when response status is #{status_code}" do
+      @response.status = status_code
+      @response.body = ['Hello World']
+      assert([status_code, {}, []]) == @response.finish
+    end
+  end
+
+  it 'does not call #to_ary or #inject on the body' do
+    object = Object.new
+    def object.inject(*) fail 'called' end
+    def object.to_ary(*) fail 'called' end
+    def object.each(*) end
+    @response.body = object
+    refute(@response.finish).nil?
+  end
+
+  it 'does not nest a RocketIO::Response' do
+    @response.body = RocketIO::Response.new ["foo"]
+    assert(@response.body).identical_to? ["foo"]
+  end
+
+  it 'does not nest a Rack::Response' do
+    @response.body = Rack::Response.new ["foo"]
+    assert(@response.body).identical_to? ["foo"]
+  end
+
+  it "sets response.body when result is a String" do
+    app mock_controller {
+      def get; 'Hello World' end
+    }
+
+    get
+    assert(last_response).is_ok_with_body 'Hello World'
+  end
+
+  it "sets response.body when result is an Array of Strings" do
+    app mock_controller {
+      def get; ['Hello', 'World'] end
+    }
+
+    get
+    assert(last_response).is_ok_with_body 'HelloWorld'
+  end
+
+  it "sets response.body when result responds to #each" do
+    app mock_controller {
+      def get
+        res = lambda { 'Hello World' }
+        def res.each ; yield call ; end
+        res
+      end
+    }
+
+    get
+    assert(last_response).is_ok_with_body 'Hello World'
+  end
+
+  it "sets response.body to [] when result is nil" do
+    app mock_controller {
+      def get; end
+    }
+
+    get
+    assert(last_response).is_ok_with_body ''
+  end
+end