manveru-innate 2009.02.25 → 2009.03.24

data/spec/innate/node/node.rb

@@ -0,0 +1,142 @@
+require 'spec/helper'
+
+Innate.options.merge!(:views => 'view', :layouts => 'view')
+
+class SpecNode
+  Innate.node('/')
+  provide(:html, :ERB)
+  provide(:erb, :None)
+
+  def foo; end
+  def bar; end
+  def one(arg) end
+  def two(arg1, arg2) end
+  def more(*args) end
+  def default(arg = nil) end
+end
+
+class SpecNodeProvide
+  Innate.node('/provide')
+
+  provide(:html, :ERB)
+  provide(:erb, :None)
+
+  def foo
+    '<%= 21 * 2 %>'
+  end
+
+  def bar
+    '<%= 84 / 2 %>'
+  end
+end
+
+class SpecNodeProvideTemplate
+  Innate.node('/provide_template')
+
+  provide :html, :ERB
+  provide :erb, :None
+
+  map_views '/'
+end
+
+class SpecNodeSub < SpecNode
+  map '/sub'
+
+  def bar(arg) end
+end
+
+class SpecNodeWithLayout < SpecNodeProvide
+  map '/layout'
+  layout 'with_layout'
+
+  map_layouts '/'
+end
+
+class SpecNodeWithLayoutView < SpecNodeProvide
+  map '/another_layout'
+  layout 'another_layout'
+
+  map_views 'node/another_layout'
+end
+
+class SpecNodeWithLayoutMethod < SpecNodeProvide
+  map '/layout_method'
+  layout 'layout_method'
+
+  def layout_method
+    '<div class="content"><%= @content %></div>'
+  end
+end
+
+class SpecNodeIndex
+  Innate.node('/spec_index')
+
+  def index
+    "I have no parameters"
+  end
+end
+
+class SpecNodeAliasView < SpecNodeProvideTemplate
+  map '/alias_view'
+  map_views '/'
+
+  alias_view :aliased, :bar
+end
+
+describe 'Innate::Node' do
+  behaves_like :mock
+
+  should 'respond with 404 if no action was found' do
+    got = Innate::Mock.get('/does_not_exist')
+    got.status.should == 404
+    got.body.should == 'No action found at: "/does_not_exist"'
+    got['Content-Type'].should == 'text/plain'
+  end
+
+  should 'wrap with layout' do
+    got = Innate::Mock.get('/layout/bar')
+    got.status.should == 200
+    got.body.should == %(<div class="content">42</div>\n)
+    got['Content-Type'].should == 'text/html'
+  end
+
+  should 'find layout with view_root' do
+    got = Innate::Mock.get('/another_layout/bar')
+    got.status.should == 200
+    got.body.should == %(<div class="content">\n  42\n</div>\n)
+    got['Content-Type'].should == 'text/html'
+  end
+
+  should 'find layout from method' do
+    got = Innate::Mock.get('/layout_method/bar')
+    got.status.should == 200
+    got.body.should == %(<div class="content">42</div>)
+    got['Content-Type'].should == 'text/html'
+  end
+
+  should 'not get an action with wrong parameters' do
+    got = Innate::Mock.get('/spec_index/bar')
+    got.status.should == 404
+    got.body.should == 'No action found at: "/bar"'
+  end
+
+  should 'get an action view if there is no method' do
+    got = Innate::Mock.get('/provide_template/only_view')
+    got.status.should == 200
+    got.body.strip.should == "Only template"
+    got['Content-Type'].should == 'text/html'
+  end
+
+  should 'not get an action view with params if there is no method' do
+    got = Innate::Mock.get('/provide_template/only_view/param')
+    got.status.should == 404
+    got.body.strip.should == 'No action found at: "/only_view/param"'
+  end
+
+  should 'use alias_view' do
+    got = get('/alias_view/aliased')
+    got.status.should == 200
+    got.body.strip.should == "<h1>Hello, World!</h1>"
+    got['Content-Type'].should == 'text/html'
+  end
+end

data/spec/innate/node/resolve.rb

@@ -0,0 +1,82 @@
+require 'spec/helper'
+
+class SpecNodeResolve
+  Innate.node('/')
+
+  def foo; end
+  def bar; end
+  def one(arg) end
+  def two(arg1, arg2) end
+  def more(*args) end
+  def default(arg = nil) end
+end
+
+class SpecNodeResolveSub < SpecNodeResolve
+  map '/sub'
+
+  def bar(arg) end
+end
+
+class SpecNodeResolveIndex
+  Innate.node('/arg')
+
+  def index(arg) end
+end
+
+describe 'Node.resolve' do
+  def compare(url, hash)
+    result = SpecNodeResolve.resolve(url)
+    result.should.not.be.nil
+    hash.each do |key, value|
+      result[key.to_s].should == value
+    end
+  end
+
+  should 'resolve actions with methods' do
+    SpecNodeResolve.resolve('/').should.be.nil
+    SpecNodeResolve.resolve('/index').should.be.nil
+
+    compare '/foo', :method => 'foo', :params => []
+    SpecNodeResolve.resolve('/foo/one/two').should.be.nil
+
+    compare '/bar', :method => 'bar', :params => []
+    SpecNodeResolve.resolve('/bar/one').should.be.nil
+
+    SpecNodeResolve.resolve('/one').should.be.nil
+    compare '/one/1', :method => 'one', :params => ['1']
+    SpecNodeResolve.resolve('/one/1/2').should.be.nil
+    SpecNodeResolve.resolve('/one/1/2/3').should.be.nil
+
+    SpecNodeResolve.resolve('/two').should.be.nil
+    SpecNodeResolve.resolve('/two/1').should.be.nil
+    compare '/two/1/2', :method => 'two', :params => %w[1 2]
+    SpecNodeResolve.resolve('/two/1/2/3').should.be.nil
+
+    compare '/more', :method => 'more', :params => []
+    compare '/more/1', :method => 'more', :params => %w[1]
+    compare '/more/1/2', :method => 'more', :params => %w[1 2]
+    compare '/more/1/2/3', :method => 'more', :params => %w[1 2 3]
+
+    compare '/default', :method => 'default', :params => []
+    compare '/default/1', :method => 'default', :params => %w[1]
+
+    # NOTE: these are actually bound to fail when called, but we cannot
+    #       introspect enough to anticipate this failure
+    compare '/default/1/2', :method => 'default', :params => %w[1 2]
+    compare '/default/1/2/3', :method => 'default', :params => %w[1 2 3]
+  end
+
+  should 'inherit action methods from superclasses' do
+    SpecNodeResolveSub.resolve('/foo').should.not.be.nil
+    SpecNodeResolveSub.resolve('/foo/one/two').should.be.nil
+  end
+
+  should 'select correct method from subclasses' do
+    SpecNodeResolveSub.resolve('/bar/one').should.not.be.nil
+    SpecNodeResolveSub.resolve('/bar').should.be.nil
+  end
+
+  it "doesn't select index as action with index parameter if arity is 1" do
+    SpecNodeResolveIndex.resolve('/index').should.be.nil
+  end
+end

data/spec/innate/node/view/with_layout.erb

@@ -0,0 +1 @@
+<div class="content"><%= @content %></div>

data/spec/innate/node/wrap_action_call.rb

@@ -0,0 +1,83 @@
+require 'spec/helper'
+
+SPEC_WRAP_LOG = []
+
+class SpecWrapActionCall
+  Innate.node '/'
+
+  def first; end
+  def second; end
+  def third; end
+
+  private
+
+  def wrap_before(action)
+    SPEC_WRAP_LOG << [:before, action.name]
+    yield
+  end
+
+  def wrap_after(action)
+    SPEC_WRAP_LOG << [:after, action.name]
+    yield
+  end
+end
+
+class SpecWrapActionCallStop
+  Innate.node '/stop'
+
+  def index; 'Hello'; end
+
+  def wrap_pass(action)
+    yield
+  end
+
+  def wrap_stop(action)
+    'No Hello'
+  end
+end
+
+
+describe 'Node#wrap_action_call' do
+  behaves_like :mock
+
+  it 'executes our wrapper' do
+    SPEC_WRAP_LOG.clear
+    SpecWrapActionCall.add_action_wrapper(2.0, :wrap_after)
+
+    get('/first')
+    SPEC_WRAP_LOG.should == [[:after, 'first']]
+
+    get('/second')
+    SPEC_WRAP_LOG.should == [[:after, 'first'], [:after, 'second']]
+
+    get('/third')
+    SPEC_WRAP_LOG.should == [[:after, 'first'], [:after, 'second'], [:after, 'third']]
+  end
+
+  it 'executes wrappers in correct order' do
+    SPEC_WRAP_LOG.clear
+    SpecWrapActionCall.add_action_wrapper(1.0, :wrap_before)
+
+    get('/first')
+    SPEC_WRAP_LOG.should == [[:before, 'first'], [:after, 'first']]
+
+    get('/second')
+    SPEC_WRAP_LOG.should == [
+      [:before, 'first'], [:after, 'first'],
+      [:before, 'second'], [:after, 'second']]
+
+    get('/third')
+    SPEC_WRAP_LOG.should == [
+      [:before, 'first'], [:after, 'first'],
+      [:before, 'second'], [:after, 'second'],
+      [:before, 'third'], [:after, 'third']]
+  end
+
+  it 'stops in the chain when not yielded' do
+    SpecWrapActionCallStop.add_action_wrapper(1.0, :wrap_pass)
+    get('/stop').body.should == 'Hello'
+
+    SpecWrapActionCallStop.add_action_wrapper(2.0, :wrap_stop)
+    get('/stop').body.should == 'No Hello'
+  end
+end

data/spec/innate/options.rb

@@ -57,19 +57,41 @@ describe Options do
     @options.deep.port.should == 7000
   end
 
+  should '#set_value to set a nested value directly' do
+    @options.set_value([:deep, :down, :me], 'me deep down')
+    @options.deep.down.me.should == 'me deep down'
+  end
+
   should 'merge! existing options with other Enumerable' do
     @options.merge!(:port => 4000, :name => 'feagliir')
     @options.port.should == 4000
     @options.name.should == 'feagliir'
   end
 
-  should 'Be Enumerable' do
-    keys, values = [], []
+  should 'iterate via #each_pair' do
+    given_keys = [:deep, :name, :port]
+    given_values = [@options[:deep], @options[:name], @options[:port]]
+
+    @options.each_pair do |key, value|
+      given_keys.delete(key)
+      given_values.delete(value)
+    end
+
+    given_keys.should.be.empty
+    given_values.should.be.empty
+  end
+
+  should 'iterate via #each_option' do
+    given_keys = [:deep, :name, :port]
+    given_values = [@options.get(:deep), @options.get(:name), @options.get(:port)]
 
-    @options.each{|k, v| keys << k; values << v }
+    @options.each_option do |key, option|
+      given_keys.delete(key)
+      given_values.delete(option)
+    end
 
-    keys.compact.sort_by{|k| k.to_s }.should == [:deep, :name, :port]
-    values.compact.size.should == 3
+    given_keys.should.be.empty
+    given_values.should.be.empty
   end
 
   should "raise when trying to assign to key that doesn't exist" do
@@ -80,7 +102,7 @@ describe Options do
     require 'pp'
     p = PP.new
     @options.pretty_print(p)
-    p.output.should =~ /:value=>4000/
+    p.output.should =~ /:value=>:mom/
   end
 
   should 'trigger block when option is changed' do

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

@@ -0,0 +1 @@
+<ul><% @users.each do |user| %><li><%= user %></li><% end %></ul>

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

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

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, :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 => :ERB, :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/request.rb

@@ -2,7 +2,7 @@ require 'spec/helper'
 
 describe Innate::Request do
   def request(env = {})
-    Innate::Request.new(env)
+    Innate::Request.new(@env.merge(env))
   end
 
   @env = {
@@ -18,7 +18,7 @@ describe Innate::Request do
     "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",
+    "QUERY_STRING"         => "a=b",
     "REMOTE_ADDR"          => "127.0.0.1",
     "REMOTE_HOST"          => "delta.local",
     "REQUEST_METHOD"       => "GET",
@@ -32,7 +32,7 @@ describe Innate::Request do
 
   should 'provide #request_uri' do
     request('REQUEST_URI' => '/?a=b').request_uri.should == '/?a=b'
-    request('PATH_INFO' => '/').request_uri.should == '/'
+    request('REQUEST_URI' => '/').request_uri.should == '/'
   end
 
   should 'provide #local_net?' do
@@ -53,13 +53,26 @@ describe Innate::Request do
     req.subset(:a, :c).should == {'a' => 'b', 'c' => 'd'}
   end
 
-  should 'provide #domain' do
-    request(@env.merge('rack.url_scheme' => 'http')).domain.should ==
-      URI('http://localhost:7000/')
-    request(@env.merge('rack.url_scheme' => 'https')).domain.should ==
-      URI('https://localhost:7000/')
-    request(@env.merge('rack.url_scheme' => 'https')).domain('/foo').should ==
-      URI('https://localhost:7000/foo')
+  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
 
   should 'provide #accept_language' do

data/spec/innate/route.rb

@@ -1,9 +1,7 @@
 require 'spec/helper'
 
 class SpecRouter
-  include Innate::Node
-  map '/'
-  provide :html => :None
+  Innate.node('/').provide(:html, :None)
 
   def float(flt)
     "Float: %3.3f" % flt
@@ -126,7 +124,7 @@ describe Innate::Rewrite do
     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")

data/spec/innate/session.rb

@@ -1,7 +1,7 @@
 require 'spec/helper'
 
 class SpecSession
-  Innate.node('/').provide(:html => :none)
+  Innate.node('/').provide(:html, :None)
 
   def index
     'No session here'

data/spec/innate/state/fiber.rb

@@ -0,0 +1,57 @@
+begin
+  require 'fiber'
+rescue LoadError
+  exit
+end
+
+require 'spec/helper'
+
+describe Innate::State::Fiber do
+  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