rjspotter-innate 2009.06.29

data/spec/innate/modes.rb

@@ -0,0 +1,61 @@
+require 'spec/helper'
+
+class SpecModeDummy
+  Innate.node '/'
+
+  def index
+    'Hello, World!'
+  end
+
+  def random
+    rand.to_s
+  end
+end
+
+describe 'Innate modes' do
+  describe 'dev' do
+    behaves_like :rack_test
+    Innate.options.mode = :dev
+
+    should 'handle GET request' do
+      get('/').status.
+        should == 200
+      last_response.headers.
+        should == {'Content-Length' => '13', 'Content-Type' => 'text/html'}
+      last_response.body.
+        should == 'Hello, World!'
+    end
+
+    should 'handle HEAD requests by omitting body' do
+      head('/').status.
+        should == 200
+      last_response.headers.
+        should == {'Content-Length' => '13', 'Content-Type' => 'text/html'}
+      last_response.body.
+        should == ''
+    end
+  end
+
+  describe 'live' do
+    behaves_like :rack_test
+    Innate.options.mode = :live
+
+    should 'handle GET request' do
+      get('/').status.
+        should == 200
+      last_response.headers.
+        should == {'Content-Length' => '13', 'Content-Type' => 'text/html'}
+      last_response.body.
+        should == 'Hello, World!'
+    end
+
+    should 'handle HEAD requests by omitting body' do
+      head('/').status.
+        should == 200
+      last_response.headers.
+        should == {'Content-Length' => '13', 'Content-Type' => 'text/html'}
+      last_response.body.
+        should == ''
+    end
+  end
+end

data/spec/innate/node/mapping.rb

@@ -0,0 +1,37 @@
+require 'spec/helper'
+
+describe 'Node::generate_mapping' do
+  def gen(const)
+    Innate::Node.generate_mapping(const)
+  end
+
+  should 'transform class names into snake_case locations' do
+    gen(     'O').should == '/o'
+    gen(    'Oo').should == '/oo'
+    gen(   'Ooo').should == '/ooo'
+    gen(  'OooO').should == '/oooo'
+    gen( 'OooOo').should == '/ooo_oo'
+    gen('OooOoo').should == '/ooo_ooo'
+    gen('OOOooo').should == '/oooooo'
+    gen('OooOOO').should == '/oooooo'
+    gen('OoOoOo').should == '/oo_oo_oo'
+  end
+
+  should 'transform namespaces into leading parts of the location' do
+    gen('O::O').should == '/o/o'
+    gen('O::O::O').should == '/o/o/o'
+    gen('O::O::O::O').should == '/o/o/o/o'
+  end
+
+  should 'transform leading parts just like standalone part' do
+    gen(     'O::O').should == '/o/o'
+    gen(    'Oo::O').should == '/oo/o'
+    gen(   'Ooo::O').should == '/ooo/o'
+    gen(  'OooO::O').should == '/oooo/o'
+    gen( 'OooOo::O').should == '/ooo_oo/o'
+    gen('OooOoo::O').should == '/ooo_ooo/o'
+    gen('OOOooo::O').should == '/oooooo/o'
+    gen('OooOOO::O').should == '/oooooo/o'
+    gen('OoOoOo::O').should == '/oo_oo_oo/o'
+  end
+end

data/spec/innate/node/node.rb

@@ -0,0 +1,135 @@
+require 'spec/helper'
+
+Innate.options.merge!(:views => 'view', :layouts => 'view')
+
+class SpecNode
+  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 SpecNodeProvide
+  Innate.node('/provide')
+
+  def foo
+    '#{21 * 2}'
+  end
+
+  def bar
+    '#{84 / 2}'
+  end
+end
+
+class SpecNodeProvideTemplate
+  Innate.node('/provide_template')
+
+  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'
+  map_layouts '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 :rack_test
+
+  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>)
+    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>)
+    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/another_layout/another_layout.xhtml

@@ -0,0 +1,3 @@
+<div class="content">
+  #{@content}
+</div>

data/spec/innate/node/view/bar.xhtml

@@ -0,0 +1 @@
+<h1>Hello, World!</h1>

data/spec/innate/node/view/foo.html.xhtml

@@ -0,0 +1 @@
+<?r 10.times do |n| ?>#{n}<?r end ?>

data/spec/innate/node/view/only_view.xhtml

@@ -0,0 +1 @@
+Only template

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

@@ -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 :rack_test
+
+  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

@@ -0,0 +1,123 @@
+require 'spec/helper'
+
+Options = Innate::Options
+
+describe Options do
+  @options = Innate::Options.new(:spec)
+
+  should 'create option' do
+    @options.o('my name', :name, 'manveru')
+    @options.name.should == 'manveru'
+  end
+
+  should 'create options with meta hash' do
+    @options.o('the port', :port, 7000, :cli => '-p')
+    @options.port.should == 7000
+  end
+
+  should 'get complete hash via #get' do
+    @options.get(:port)[:cli].should == '-p'
+    @options.get(:port)[:doc].should == 'the port'
+  end
+
+  should 'get value via []' do
+    @options[:port].should == 7000
+  end
+
+  should 'create scope' do
+    @options.sub(:deep)
+    @options.deep.should.not.be.nil
+  end
+
+  should 'create option in scope' do
+    @options.deep.o('the browser', :browser, :firefox)
+    @options.deep.browser.should == :firefox
+  end
+
+  should 'append to scope via dsl' do
+    @options.sub(:deep).o('hi mom', :greeting, :mom)
+    @options.deep.greeting.should == :mom
+  end
+
+  should 'sub in subscope' do
+    @options.sub(:deep).sub(:down).o('deep down', :me, :too)
+    @options.deep.down.me.should == :too
+  end
+
+  should 'get sub-sub option' do
+    @options.get(:deep, :down, :me).
+      should == {:value => :too, :doc => 'deep down'}
+  end
+
+  should 'respond with nil on getting missing option' do
+    @options.get(:deep, :down, :you).should.be.nil
+  end
+
+  should 'search in higher scope if key not found' 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 '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_option do |key, option|
+      given_keys.delete(key)
+      given_values.delete(option)
+    end
+
+    given_keys.should.be.empty
+    given_values.should.be.empty
+  end
+
+  should "raise when trying to assign to key that doesn't exist" do
+    lambda{ @options[:foo] = :bar }.should.raise(ArgumentError)
+  end
+
+  should "raise when trying to assign to an option that doesn't exist" do
+    lambda{ @options.merge!(:foo => :bar) }.should.raise(IndexError)
+  end
+
+  should 'pretty_print' do
+    require 'pp'
+    p = PP.new
+    @options.pretty_print(p)
+    lines = p.output.split(/\n/)
+    lines.find_all{|l|
+      /:doc/ === l &&
+      /:value/ === l
+    }.size.should > 3
+  end
+
+  should 'trigger block when option is changed' do
+    set = nil
+    @options.trigger(:port){|value| set = value }
+    set.should.be.nil
+    @options.port = 300
+    set.should == 300
+  end
+end