ramaze 0.3.9.1 → 2023.01.06

data/spec/ramaze/current/session.rb

@@ -1,97 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TrinitySessionController < Ramaze::Controller
-  map :/
-
-  def index
-    "nothing"
-  end
-
-  def val
-    session.client[:val]
-  end
-
-  def set
-    session.client[:val] = 789
-  end
-
-  def del
-    session.client.delete(:val)
-  end
-end
-
-describe "Session" do
-  behaves_like 'http'
-  ramaze :sessions => false
-
-  it 'should work without sessions' do
-    class Ramaze::Session
-      remove_const :IP_COUNT_LIMIT
-      const_set(:IP_COUNT_LIMIT, 2)
-    end
-    (Ramaze::Session::IP_COUNT_LIMIT + 2).times do
-      r = get('/')
-      r.body.should == "nothing"
-      r.headers.should == {'Content-Type' => 'text/html'}
-    end
-  end
-end
-
-describe "Session cookie store" do
-  behaves_like 'http'
-  ramaze :sessions => true
-
-  Ramaze::Session::SESSION_KEY.replace('sess')
-  @secret = Ramaze::Session.trait[:secret] = 'abc'
-
-  # Marshal a session hash into safe cookie data. Include an integrity hash.
-  def marshal(session)
-    data = [ Marshal.dump(session) ].pack('m').chop
-    "#{data}--#{generate_digest(data)}"
-  end
-
-  # Unmarshal cookie data to a hash and verify its integrity.
-  def unmarshal(cookie)
-    if cookie
-      data, digest = cookie.split('--')
-      return {} unless digest == generate_digest(data)
-      Marshal.load(data.unpack('m').first)
-    end
-  end
-
-  # Generate the inline SHA512 message digest. Larger (128 bytes) than SHA256
-  # (64 bytes) or RMD160 (40 bytes), but small relative to the 4096 byte
-  # max cookie size.
-  def generate_digest(data)
-    Digest::SHA512.hexdigest "#{data}#{@secret}"
-  end
-
-  it 'should use session data from cookies' do
-    r = get('/val', :cookie => "sess-client="+marshal({ :val => 123 }))
-    r.body.should == '123'
-  end
-
-  it 'should use new values from session cookie' do
-    r = get('/val', :cookie => "sess-client="+marshal({ :val => 456 }))
-    r.body.should == '456'
-  end
-
-  it 'should set session values in the cookie' do
-    r = get('/set')
-    r.headers['Set-Cookie'].should == "sess-client=#{CGI.escape(marshal({:val => 789}))}; path=/"
-  end
-
-  it 'bad cookie should be ignored' do
-    r = get('/val', :cookie => marshal({ :val => 456 }) + 'wrong')
-    r.body.should.not == '456'
-  end
-
-  it 'should allow removing the last key/value pair' do
-    r = get('/del', :cookie => "sess-client="+marshal({ :val => 456 }))
-    r.body.should == '456'
-    r.headers['Set-Cookie'].should == "sess-client=#{CGI.escape(marshal({}))}; path=/"
-  end
-end

data/spec/ramaze/dispatcher.rb

@@ -1,31 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TCDispatcherController < Ramaze::Controller
-  map '/'
-
-  def index
-    "Hello, World!"
-  end
-end
-
-describe "Dispatcher" do
-  behaves_like 'http'
-  ramaze :ignore => ['/favicon.ico', '/robots.txt'],
-    :ignore_body => 'File not found'
-
-  it 'should resolve a normal request' do
-    page = get('/')
-    page.status.should == 200
-    page.body.should == 'Hello, World!'
-  end
-
-  it 'should ignore /foo.ico' do
-    Ramaze::Global.ignore = ['/foo.ico']
-    page = get('/foo.ico')
-    page.status.should == 404
-    page.body.should == 'File not found'
-  end
-end

data/spec/ramaze/element.rb

@@ -1,107 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TCElementController < Ramaze::Controller
-  engine :Ezamar
-
-  def index
-    "The index"
-  end
-
-  def elementy
-    "<Page>#{index}</Page>"
-  end
-
-  def nested
-    "<Page> some stuff <Page>#{index}</Page> more stuff </Page>"
-  end
-
-  def with_params(*params)
-    hash = Hash[*params.flatten].map{|k,v| %{#{k}="#{v}"}}.join(' ')
-    %{<PageWithParams #{hash}></PageWithParams>}
-  end
-
-  def little
-    %{<PageLittle />}
-  end
-
-  def little_params(*params)
-    hash = Hash[*params.flatten].map{|k,v| %{#{k}="#{v}"}}.join(' ')
-    %{<PageLittleWithParams #{hash} />}
-  end
-
-  def templating(times)
-    %{<PageWithTemplating times="#{times}" />}
-  end
-end
-
-class Page < Ezamar::Element
-  def render
-    %{ <wrap> #{content} </wrap> }
-  end
-end
-
-
-class PageWithParams < Ezamar::Element
-  def render
-    ivs = (instance_variables - ['@content', :@content])
-    ivs.inject({}){|s,v| s.merge(v.to_s => instance_variable_get(v)) }.inspect
-  end
-end
-
-class PageLittle < Ezamar::Element
-  def render
-    "little"
-  end
-end
-
-class PageLittleWithParams < Ezamar::Element
-  def render
-    ivs = (instance_variables - ['@content', :@content])
-    ivs.inject({}){|s,v| s.merge(v.to_s => instance_variable_get(v)) }.inspect
-  end
-end
-
-class PageWithTemplating < Ezamar::Element
-  def render
-    (1..@times).to_a.join(', ')
-  end
-end
-
-describe "Element" do
-  ramaze(:mapping => {'/' => TCElementController})
-
-  def retrieve(*url)
-    Ramaze::Controller.handle(*url).strip
-  end
-
-  it "simple request" do
-    retrieve('/').should == "The index"
-  end
-
-  it "with element" do
-    retrieve('/elementy').should == "<wrap> The index </wrap>"
-  end
-
-  it "nested element" do
-    retrieve('/nested').should == "<wrap>  some stuff  <wrap> The index </wrap>  more stuff  </wrap>"
-  end
-
-  it "with_params" do
-    retrieve('/with_params/one/two').should == {'@one' => 'two'}.inspect
-  end
-
-  it "little" do
-    retrieve('/little').should == 'little'
-  end
-
-  it "little params" do
-    retrieve('/little_params/one/eins').should == {'@one' => 'eins'}.inspect
-  end
-
-  it "templating" do
-    retrieve('/templating/10').should == (1..10).to_a.join(', ')
-  end
-end

data/spec/ramaze/helper/aspect.rb

@@ -1,92 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TCAspectController < Ramaze::Controller
-  map '/'
-  trait :foo => :bar
-  helper :aspect
-
-  def test_before() request[:before] += 2 end
-  before(:test_before){ request[:before] = 40 }
-
-  def test_after() request[:after] = 40 end
-  after(:test_after){ request[:after] += 2 }
-
-  def test_wrap() end
-  wrap(:test_wrap){ request[:wrap] ||= 0; request[:wrap] += 21 }
-
-  wrap(:test_template) { '<aspect>' }
-end
-
-class TCAspectAllController < Ramaze::Controller
-  map '/all'
-
-  helper :aspect
-  template_root __DIR__/:template
-
-  def test_all_first() 'first' end
-  def test_all_second() 'second' end
-
-  before_all{ request[:all] = 40 }
-  after_all{ request[:all] += 2 }
-
-  def test_all_after() 'after' end
-
-  def layout() '<div>#@content</div>' end
-  template :loop_with_layout, :loop
-  layout :layout => [:loop_with_layout]
-end
-
-describe "AspectHelper" do
-  behaves_like 'http'
-  ramaze :error_page => false
-  extend Ramaze::Trinity
-
-  it "shouldn't overwrite traits on inclusion" do
-    TCAspectController.trait[:foo].should == :bar
-  end
-
-  it 'should use before' do
-    get('/test_before')
-    request[:before].should == 42 
-  end
-
-  it 'should use after' do
-    get('/test_after')
-    request[:after].should == 42 
-  end
-
-  it 'should use wrap' do
-    get('/test_wrap')
-    request[:wrap].should == 42 
-  end
-
-  it 'should before_all and after_all' do
-    get('/all/test_all_first')
-    request[:all].should == 42
-    get('/all/test_all_second')
-    request[:all].should == 42
-  end
-
-  it 'should before_all and after_all for templates' do
-    get('/all/test_template')
-    request[:all].should == 42
-  end
-
-  it 'should before_all and after_all for all defined actions' do
-    get('/all/test_all_after')
-    request[:all].should == 42
-  end
-
-  it 'should not apply aspects to render_template' do
-    get('/all/loop').body.gsub(/\s/,'').should == '12345'
-    request[:all].should == 42
-  end
-
-  it 'should not apply aspects to layouts' do
-    get('/all/loop_with_layout').body.gsub(/\s/,'').should == '<div>12345</div>'
-    request[:all].should == 42
-  end
-end

data/spec/ramaze/helper/cgi.rb

@@ -1,43 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-require 'ramaze/helper/cgi'
-
-class TCLink < Ramaze::Controller
-  map '/'
-end
-
-describe "url encode" do
-  extend Ramaze::Helper::CGI
-
-  it 'should url_encode strings' do
-    # ok, I believe that the web is dumb for this
-    # but this probably is a SHOULD thingy in the HTTP RFC
-    url_encode('title with spaces').should == 'title+with+spaces'
-    url_encode('[foo]').should == '%5Bfoo%5D'
-    u('//').should == '%2F%2F'
-  end
-  it 'should url_decode strings' do
-    url_decode('title%20with%20spaces').should == 'title with spaces'
-    url_decode('title+with+spaces').should == 'title with spaces'
-  end
-  it 'should be reversible' do
-    url_decode(u('../ etc/passwd')).should == '../ etc/passwd'
-  end
-end
-
-describe 'html escape' do
-  extend Ramaze::Helper::CGI
-
-  it 'should escape html' do
-    html_escape('& < >').should == '&amp; &lt; &gt;'
-    h('<&>').should == '&lt;&amp;&gt;'
-  end
-  it 'should unescape html' do
-    html_unescape('&lt; &amp; &gt;').should == '< & >'
-  end
-  it 'should be reversible' do
-    html_unescape(html_escape('2 > b && b <= 0')).should == '2 > b && b <= 0'
-  end
-end

data/spec/ramaze/helper/file.rb

@@ -1,18 +0,0 @@
-require 'spec/helper'
-
-class TCFileHelper < Ramaze::Controller
-  map '/'
-
-  def index
-    send_file(__FILE__)
-  end
-end
-
-describe 'FileHelper' do
-  behaves_like 'http'
-  ramaze
-
-  it 'serving a file' do
-    get('/').body.strip.should == File.read(__FILE__).strip
-  end
-end

data/spec/ramaze/helper/pager.rb

@@ -1,99 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-spec_require 'hpricot'
-
-module Og
-  class Mock
-    def initialize(*a); @a = a; end
-    def all(o) @a[(o[:offset]||0),o[:limit]] end
-    def count(*a) @a.size end
-    alias reload all
-  end
-  module Mixin; end
-  module Collection; end
-end
-
-class TCPagerController < Ramaze::Controller
-  map '/'
-  helper :pager
-
-  def page
-    stuff = [1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-    items, pager = paginate(stuff, :limit => 2)
-
-    items.inspect
-  end
-
-end
-
-ramaze
-
-shared 'pager' do
-  behaves_like 'http'
-  behaves_like 'resolve'
-  extend Ramaze::Helper::Pager
-
-  def pager_key
-    Ramaze::Pager.trait[:key]
-  end
-
-  # Used internally in Pager to get parameters like: ?_page=1
-  def request
-    req = Object.new
-    def req.params
-      {Ramaze::Pager.trait[:key] => 1}
-    end
-    req
-  end
-
-  before do
-    @items, @pager = paginate(@stuff, :limit => 2)
-  end
-
-  it 'should be paginated' do
-    get('/page').body.should == [1, 2].inspect
-    get('/page', pager_key => '2').body.should == [3, 4].inspect
-  end
-
-  it "should report the number of articles as Pager#total_count" do
-    @pager.should.not.be.nil
-    @pager.total_count.should.equal 5
-  end
-
-  it "should return the same number of items as passed to :per_page" do
-    @items.should.not.be.nil
-    @items.size.should.equal 2
-  end
-
-  it "should link to other pages" do
-    stack('/page') do
-      @pager.should.not.be.nil
-      @pager.navigation.should.not.be.nil
-
-      page = Hpricot(@pager.navigation)
-      (page / 'a').size.should == 4
-    end
-  end
-end
-
-describe "Array Pager" do
-  @stuff = (1..5).to_a
-
-  behaves_like "pager"
-end
-
-describe "OgPager" do
-  @stuff = Og::Mock.new(1,2,3,4,5).extend(Og::Mixin)
-
-  behaves_like "pager"
-end
-
-describe "OgCollectionPager" do
-  @stuff = Og::Mock.new(1,2,3,4,5).extend(Og::Collection)
-
-  behaves_like "pager"
-end

data/spec/ramaze/helper/partial.rb

@@ -1,76 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TCPartialHelperController < Ramaze::Controller
-  map '/'
-
-  def index
-    '<html><head><title>#{render_partial("/title")}</title></head></html>'
-  end
-
-  def title
-    "Title"
-  end
-
-  def composed
-    @here = 'there'
-    'From Action | ' +
-    render_template("partial.xhtml")
-  end
-
-  def recursive locals = false
-    respond render_template('recursive_locals.xhtml', :n => 1) if locals
-    @n = 1
-  end
-
-  def test_locals
-    render_template 'locals.xhtml', :say => 'Hello', :to => 'World'
-  end
-
-  def test_local_ivars
-    render_template 'recursive_local_ivars.xhtml', :n => 1
-  end
-
-  def test_without_ext
-    render_template :locals, :say => 'Hi', :to => 'World'
-  end
-end
-
-describe "PartialHelper" do
-  behaves_like 'http'
-  ramaze
-
-  it "should render partials" do
-    get('/').body.should == '<html><head><title>Title</title></head></html>'
-  end
-
-  it 'should be able to render a template in the current scope' do
-    get('/composed').body.should == 'From Action | From Partial there'
-  end
-
-  it 'should render_template in a loop' do
-    get('/loop').body.gsub(/\s/,'').should == '12345'
-  end
-
-  it 'should work recursively' do
-    get('/recursive').body.gsub(/\s/,'').should == '{1{2{3{44}4}3}2}'
-  end
-
-  it 'should support locals' do
-    get('/test_locals').body.should == 'Hello, World!'
-  end
-
-  it 'should work recursively with locals' do
-    get('/recursive/true').body.gsub(/\s/,'').should == '{1{2{3{44}3}2}1}'
-  end
-
-  it 'should set ivars in addition to locals' do
-    get('/test_local_ivars').body.gsub(/\s/,'').should == '{1{2{3{44}3}2}1}'
-  end
-
-  it 'should not require file extension' do
-    get('/test_without_ext').body.should == 'Hi, World!'
-  end
-end

data/spec/ramaze/helper/redirect.rb

@@ -1,112 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TCRedirectHelperController < Ramaze::Controller
-  map :/
-
-  def index
-    self.class.name
-  end
-
-  def noop
-    'noop'
-  end
-
-  def redirection
-    redirect :index
-  end
-
-  def double_redirection
-    redirect :redirection
-  end
-
-  def redirect_referer_action
-    redirect_referer
-  end
-
-  def no_actual_redirect
-    catch(:redirect){ redirection }
-    'foo'
-  end
-
-  def no_actual_double_redirect
-    catch(:redirect){ double_redirection }
-    'bar'
-  end
-
-  def redirect_method
-    redirect Rs(:noop)
-  end
-
-  def absolute_uri_redirect
-    redirect 'http://localhost:7007/noop'
-  end
-
-  def loop
-    respond 'no loop'
-    'loop'
-  end
-
-  def respond_with_status
-    respond 'not found', 404
-  end
-
-  def redirect_unmodified
-    raw_redirect '/noop'
-  end
-end
-
-describe "RedirectHelper" do
-  behaves_like 'http', 'browser'
-  ramaze(:adapter => :webrick)
-
-  b = Browser.new
-
-  it "testrun" do
-    b.get('/').should == "TCRedirectHelperController"
-  end
-
-  it "should do redirection" do
-    b.story do
-      get('/redirection').should == "TCRedirectHelperController"
-      get('/double_redirection').should == "TCRedirectHelperController"
-    end
-  end
-
-  it 'should be possible to catch a redirect' do
-    b.story do
-      get('/no_actual_redirect').should == 'foo'
-      get('/no_actual_double_redirect').should == 'bar'
-    end
-  end
-
-  it "should redirect to referer" do
-    b.story do
-      get('/').should == "TCRedirectHelperController"
-      get('/redirect_referer_action').should == 'TCRedirectHelperController'
-      get('/noop').should == 'noop'
-      get('/redirect_referer_action').should == 'noop'
-    end
-  end
-
-  it "should work with R()" do
-    b.get('/redirect_method').should == 'noop'
-  end
-
-  it "should work with absolute uris" do
-    b.get('/absolute_uri_redirect').should == 'noop'
-  end
-
-  it 'should allow respond() that ignores return values and templates' do
-    get('/loop').body.should == 'no loop'
-    page = get('/respond_with_status')
-    page.status.should == 404
-    page.body.should == 'not found'
-  end
-
-  it 'should redirect without modifying the target' do
-    get('/redirect_unmodified').headers['Location'].should == '/noop'
-  end
-end