rocketio 0.0.0.pre.alpha → 0.0.0

data/test/render/master.erb

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

data/test/render/post.erb

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

data/test/render/put.erb

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

data/test/render/render_test.rb

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

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

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

data/test/render/templates/master.erb

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

data/test/render/templates_test.rb

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

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

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