innate 2009.04

data/spec/innate/provides.rb

@@ -0,0 +1,99 @@
+begin
+  require 'json'
+rescue LoadError
+  exit
+end
+
+require 'spec/helper'
+require 'yaml'
+
+Innate.options.merge!(:views => 'provides', :layouts => 'provides')
+
+class SpecNodeProvides
+  Innate.node '/'
+
+  provide(:html, :engine => :None)
+  provide(:yaml, :type => 'text/yaml'){|a,s| s.to_yaml }
+  provide(:json, :type => 'application/json'){|a,s| s.to_json }
+
+  def object
+    {'intro' => 'Hello, World!'}
+  end
+
+  def string
+    'Just 42'
+  end
+end
+
+class SpecNodeProvidesTemplates
+  Innate.node '/template'
+  map_views '/'
+
+  provide(:yaml, :type => 'text/yaml'){|a,s| s.to_yaml }
+  provide(:json, :type => 'application/json'){|a,s| s.to_json }
+  provide(:txt, :engine => :Etanni, :type => 'text/plain')
+
+  def list
+    @users = %w[starbucks apollo athena]
+  end
+end
+
+shared :assert_wish do
+  def assert_wish(uri, body, content_type)
+    got = get(uri)
+    got.status.should == 200
+    got.body.strip.should == body.strip
+    got['Content-Type'].should == content_type
+  end
+end
+
+describe 'Content representation' do
+  describe 'without template' do
+    behaves_like :mock, :assert_wish
+
+    it 'provides yaml for an object' do
+      assert_wish('/object.yaml', {'intro' => 'Hello, World!'}.to_yaml, 'text/yaml')
+    end
+
+    it 'provides json for an object' do
+      assert_wish('/object.json', {'intro' => 'Hello, World!'}.to_json, 'application/json')
+    end
+
+    it 'provides html for an object' do
+      assert_wish('/string.html', 'Just 42', 'text/html')
+    end
+
+    it 'defaults to html presentation' do
+      assert_wish('/string', 'Just 42', 'text/html')
+    end
+  end
+
+  describe 'with templates' do
+    behaves_like :mock, :assert_wish
+
+    it 'defaults to <name>.html.<engine>' do
+      body = '<ul><li>starbucks</li><li>apollo</li><li>athena</li></ul>'
+      assert_wish('/template/list', body, 'text/html')
+    end
+
+    it 'uses explicit wish for <name>.html.<engine>' do
+      body = '<ul><li>starbucks</li><li>apollo</li><li>athena</li></ul>'
+      assert_wish('/template/list.html', body, 'text/html')
+    end
+
+    it 'fails when the wish cannot be satisfied' do
+      got = get('/template/list.svg')
+      got.status.should == 404
+    end
+
+    it 'uses the object returned from the action method for block provides' do
+      body = %w[starbucks apollo athena].to_yaml
+      assert_wish('/template/list.yaml', body, 'text/yaml')
+    end
+
+    it 'uses explicit wish for <name>.txt.<engine>' do
+      body = "starbucks\napollo\nathena"
+      assert_wish('/template/list.txt', body, 'text/plain')
+    end
+  end
+end

data/spec/innate/provides/list.html.xhtml

@@ -0,0 +1 @@
+<ul><?r @users.each do |user| ?><li>#{user}</li><?r end ?></ul>

data/spec/innate/provides/list.txt.xhtml

@@ -0,0 +1 @@
+<?r @users.each do |user| ?>#{"#{user}\n"}<?r end ?>

data/spec/innate/request.rb

@@ -0,0 +1,77 @@
+require 'spec/helper'
+
+describe Innate::Request do
+  def request(env = {})
+    Innate::Request.new(@env.merge(env))
+  end
+
+  @env = {
+    "GATEWAY_INTERFACE"    => "CGI/1.1",
+    "HTTP_ACCEPT"          => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "HTTP_ACCEPT_CHARSET"  => "UTF-8,*",
+    "HTTP_ACCEPT_ENCODING" => "gzip,deflate",
+    "HTTP_ACCEPT_LANGUAGE" => "en-us,en;q=0.8,de-at;q=0.5,de;q=0.3",
+    "HTTP_CACHE_CONTROL"   => "max-age=0",
+    "HTTP_CONNECTION"      => "keep-alive",
+    "HTTP_HOST"            => "localhost:7000",
+    "HTTP_KEEP_ALIVE"      => "300",
+    "HTTP_USER_AGENT"      => "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.5) Gecko/2008123017 Firefox/3.0.4 Ubiquity/0.1.4",
+    "HTTP_VERSION"         => "HTTP/1.1",
+    "PATH_INFO"            => "/",
+    "QUERY_STRING"         => "a=b",
+    "REMOTE_ADDR"          => "127.0.0.1",
+    "REMOTE_HOST"          => "delta.local",
+    "REQUEST_METHOD"       => "GET",
+    "REQUEST_PATH"         => "/",
+    "REQUEST_URI"          => "http://localhost:7000/",
+    "SCRIPT_NAME"          => "",
+    "SERVER_NAME"          => "localhost",
+    "SERVER_PORT"          => "7000",
+    "SERVER_PROTOCOL"      => "HTTP/1.1",
+  }
+
+  should 'provide #request_uri' do
+    request('REQUEST_URI' => '/?a=b').request_uri.should == '/?a=b'
+    request('REQUEST_URI' => '/').request_uri.should == '/'
+  end
+
+  should 'provide #local_net?' do
+    request.local_net?('192.168.0.1').to_s.should == '192.168.0.0'
+    request.local_net?('252.168.0.1').should == nil
+    request.local_net?('unknown').should == nil
+    request('REMOTE_ADDR' => '211.3.129.47, 66.249.85.131').local_net?.should == nil
+    request('REMOTE_ADDR' => '211.3.129.47').local_net?.should == nil
+  end
+
+  should 'provide #subset' do
+    params = {'a' => 'b', 'c' => 'd', 'e' => 'f'}
+    env = { 'rack.request.form_hash' => params }
+    req = request(env)
+
+    req.params.should == params
+    req.subset(:a).should == {'a' => 'b'}
+    req.subset(:a, :c).should == {'a' => 'b', 'c' => 'd'}
+  end
+
+  should 'provide #domain on http' do
+    request('rack.url_scheme' => 'http').domain.
+      should == URI('http://localhost:7000/')
+
+    request('rack.url_scheme' => 'http').domain('/foo').
+      should == URI('http://localhost:7000/foo')
+
+    request('rack.url_scheme' => 'http').domain('/foo', :keep_query => true).
+      should == URI('http://localhost:7000/foo?a=b')
+  end
+
+  should 'provide #domain on https' do
+    request('rack.url_scheme' => 'https').domain.
+      should == URI('https://localhost:7000/')
+
+    request('rack.url_scheme' => 'https').domain('/foo').
+      should == URI('https://localhost:7000/foo')
+
+    request('rack.url_scheme' => 'https').domain('/foo', :keep_query => true).
+      should == URI('https://localhost:7000/foo?a=b')
+  end
+end

data/spec/innate/route.rb

@@ -0,0 +1,135 @@
+require 'spec/helper'
+
+class SpecRouter
+  Innate.node('/').provide(:html, :None)
+
+  def float(flt)
+    "Float: %3.3f" % flt
+  end
+
+  def string(str)
+    "String: #{str}"
+  end
+
+  def price(p)
+    "Price: \$#{p}"
+  end
+
+  def sum(a, b)
+    a.to_i + b.to_i
+  end
+
+  def bar
+    'this is bar'
+  end
+end
+
+Route, Rewrite = Innate::Route, Innate::Rewrite
+
+describe Innate::Route do
+  def check(uri, status, body = nil)
+    got = Innate::Mock.get(uri)
+    got.status.should == status
+    got.body.should == body if body
+  end
+
+  should 'take lambda routers' do
+    Route['string'] = lambda{|path, req|
+      path if path =~ %r!^/string!
+    }
+    Route['string'].class.should == Proc
+
+    Route['calc sum'] = lambda{|path, req|
+      if req[:do_calc]
+        lval, rval = req[:a, :b]
+        rval = rval.to_i * 10
+        "/sum/#{lval}/#{rval}"
+      end
+    }
+
+    Innate::Route('foo') do |path, req|
+      '/bar' if req[:bar]
+    end
+  end
+
+  should 'define string routes' do
+    Route['/foobar'] = '/bar'
+    Route['/foobar'].should == '/bar'
+  end
+
+  should 'define regex routes' do
+    Route[%r!^/(\d+\.\d{2})$!] = "/price/%.2f"
+    Route[%r!^/(\d+\.\d{2})$!].should == "/price/%.2f"
+
+    Route[%r!^/(\d+\.\d+)!] = "/float/%.3f"
+    Route[%r!^/(\d+\.\d+)!].should == "/float/%.3f"
+
+    Route[%r!^/(\w+)!] = "/string/%s"
+    Route[%r!^/(\w+)!].should == "/string/%s"
+  end
+
+  should 'be used at /float' do
+    check('/123.123', 200, 'Float: 123.123')
+  end
+
+  should 'be used at /string' do
+    check('/foo', 200, 'String: foo')
+  end
+
+  should 'use %.3f' do
+    check('/123.123456', 200, 'Float: 123.123')
+  end
+
+  should 'resolve in the order added' do
+    check('/12.84', 200, 'Price: $12.84')
+  end
+
+  should 'use lambda routers' do
+    check('/string/abc', 200, 'String: abc')
+
+    check('/?do_calc=1&a=2&b=6', 200, '62')
+  end
+
+  it 'should support Route() with blocks' do
+    check('/foo?bar=1', 200, 'this is bar')
+  end
+
+  it 'should support string route translations' do
+    check('/foobar', 200, 'this is bar')
+  end
+
+  it 'should clear routes' do
+    Route::ROUTES.size.should > 0
+    Route.clear
+    Route::ROUTES.size.should == 0
+  end
+
+  it 'should not recurse given a bad route' do
+    Innate::Route[ %r!^/good/(.+)$! ] = "/bad/%s"
+    check('/good/hi', 404)
+  end
+end
+
+describe Innate::Rewrite do
+  Innate::Rewrite[ %r!^/(.+)$! ] = "/string/%s"
+
+  it 'should rewrite on non-existent actions' do
+    got = Innate::Mock.get('/hello')
+    got.status.should == 200
+    got.body.should == 'String: hello'
+  end
+
+  it 'should exclude existing actions' do
+    got = Innate::Mock.get('/bar')
+    got.status.should == 200
+    got.body.should == 'this is bar'
+  end
+
+  it 'should rewite with (key, val)' do
+    Innate::Rewrite[ %r!^/(.+)$! ] = nil
+    Innate::Rewrite(%r!^/(.+)$!, "/string/%s")
+    got = Innate::Mock.get('/hello')
+    got.status.should == 200
+    got.body.should == 'String: hello'
+  end
+end

data/spec/innate/session.rb

@@ -0,0 +1,54 @@
+require 'spec/helper'
+
+class SpecSession
+  Innate.node('/').provide(:html, :None)
+
+  def index
+    'No session here'
+  end
+
+  def init
+    session[:counter] = 0
+  end
+
+  def view
+    session[:counter]
+  end
+
+  def increment
+    session[:counter] += 1
+  end
+
+  def decrement
+    session[:counter] -= 1
+  end
+
+  def reset
+    session.clear
+  end
+end
+
+describe Innate::Session do
+  behaves_like :mock
+
+  should 'initiate session as needed' do
+    get '/'
+    last_response.body.should == 'No session here'
+    last_response['Set-Cookie'].should == nil
+
+    get('/init')
+    last_response.body.should == '0'
+
+    1.upto(10) do |n|
+      get('/increment').body.should == n.to_s
+    end
+
+    get('/reset')
+    get('/view').body.should == ''
+    get('/init').body.should == '0'
+
+    -1.downto(-10) do |n|
+      get('/decrement').body.should == n.to_s
+    end
+  end
+end

data/spec/innate/state/fiber.rb

@@ -0,0 +1,58 @@
+require 'spec/helper'
+
+describe 'Innate::State::Fiber' do
+  begin
+    require 'fiber'
+  rescue LoadError
+    it('needs fiber'){ should.flunk('needed fiber') }
+    exit
+  end
+
+  F = Innate::State::Fiber
+
+  it 'sets value in current thread with #[]=' do
+    Innate::Fiber.new{
+      t = F.new
+      t[:a] = :b
+      Fiber.current[:a].should == :b
+    }.resume
+  end
+
+  it 'gets value in current thread with #[]' do
+    Innate::Fiber.new{
+      t = F.new
+      Fiber.current[:b] = :c
+      t[:b].should == :c
+    }.resume
+  end
+
+  it 'executes block in #wrap' do
+    Innate::Fiber.new{
+      t = F.new
+      t.wrap{ :foo }.should == :foo
+    }.resume
+  end
+
+  it 'reraises exceptions occured in #wrap thread' do
+    Innate::Fiber.new{
+      t = F.new
+      Thread.abort_on_exception = false
+      lambda{ t.wrap{ raise 'foo' } }.should.raise
+    }.resume
+  end
+
+  it 'defers execution of passed block in #defer' do
+    Innate::Fiber.new{
+      t = F.new
+      t.defer{ :foo }.value.should == :foo
+    }.resume
+  end
+
+  it 'copies thread variables to thread spawned in #defer' do
+    Innate::Fiber.new{
+      t = F.new
+      t[:a] = :b
+      t.defer{ Fiber.current[:a] }.value.should == :b
+    }.resume
+  end
+end

data/spec/innate/state/thread.rb

@@ -0,0 +1,40 @@
+require 'spec/helper'
+require 'innate/state/thread'
+
+describe Innate::State::Thread do
+  T = Innate::State::Thread
+
+  it 'sets value in current thread with #[]=' do
+    t = T.new
+    t[:a] = :b
+    Thread.current[:a].should == :b
+  end
+
+  it 'gets value in current thread with #[]' do
+    t = T.new
+    Thread.current[:b] = :c
+    t[:b].should == :c
+  end
+
+  it 'executes block in #wrap' do
+    t = T.new
+    t.wrap{ :foo }.should == :foo
+  end
+
+  it 'reraises exceptions occured in #wrap thread' do
+    t = T.new
+    Thread.abort_on_exception = false
+    lambda{ t.wrap{ raise 'foo' } }.should.raise
+  end
+
+  it 'defers execution of passed block in #defer' do
+    t = T.new
+    t.defer{ :foo }.value.should == :foo
+  end
+
+  it 'copies thread variables to thread spawned in #defer' do
+    t = T.new
+    t[:a] = :b
+    t.defer{ Thread.current[:a] }.value.should == :b
+  end
+end