innate 2009.04

data/spec/innate/node/node.rb

@@ -0,0 +1,134 @@
+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'
+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>)
+    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 :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

@@ -0,0 +1,115 @@
+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', :trigger=> nil}
+  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 'pretty_print' do
+    require 'pp'
+    p = PP.new
+    @options.pretty_print(p)
+    p.output.should =~ /:value=>:mom/
+  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

data/spec/innate/parameter.rb

@@ -0,0 +1,154 @@
+require 'spec/helper'
+
+class SpecParameter
+  include Innate::Node
+  map '/'
+
+  def index
+    "index"
+  end
+
+  def no_params
+    "no params"
+  end
+
+  def single_param param
+    "single param (#{param})"
+  end
+
+  def double_param param1, param2
+    "double param (#{param1}, #{param2})"
+  end
+
+  def all_params *params
+    "all params (#{params.join(', ')})"
+  end
+
+  def at_least_one param, *params
+    "at least one (#{param}, #{params.join(', ')})"
+  end
+
+  def one_default param = 'default'
+    "one_default (#{param})"
+  end
+
+  def cat1__cat11
+    'cat1: cat11'
+  end
+
+  def cat1__cat11__cat111
+    'cat1: cat11: cat111'
+  end
+end
+
+class SpecParameter2
+  include Innate::Node
+  map '/jo'
+
+  def add(one, two = nil, three = nil)
+    "#{one}:#{two}:#{three}"
+  end
+
+  def keys
+    request.params.keys.inspect
+  end
+end
+
+class SpecParameter3
+  include Innate::Node
+  map '/ma'
+
+  def index(*args)
+    request.params['foo'].to_s.dump
+  end
+end
+
+describe "Simple Parameters" do
+  def handle(*url)
+    response = Innate::Mock.get(*url)
+    response.status.should == 200
+    response.body
+  end
+
+  it "Should respond to no parameters given" do
+    handle('/no_params').should == "no params"
+  end
+
+  it "Should respond to only / with the index" do
+    handle('/').should == "index"
+  end
+
+  it "call /bar though index doesn't take params" do
+    lambda{ handle('/bar') }.should.raise
+  end
+
+  it "action that takes a single param" do
+    handle('/single_param/foo').should == "single param (foo)"
+  end
+
+  it "action that takes two params" do
+    handle('/double_param/foo/bar').should == "double param (foo, bar)"
+  end
+
+  it "action that takes two params but we give only one" do
+    lambda{ handle('/double_param/foo') }.should.raise
+  end
+
+  it "action that takes all params" do
+    handle('/all_params/foo/bar/foobar').should == "all params (foo, bar, foobar)"
+  end
+
+  it "action that takes all params but needs at least one" do
+    handle('/at_least_one/foo/bar/foobar').should == "at least one (foo, bar, foobar)"
+  end
+
+  it "action that takes all params but needs at least one (not given here)" do
+    lambda{ handle('/at_least_one') }.
+      should.raise(ArgumentError)
+  end
+
+  it "one default" do
+    handle('/one_default').should == "one_default (default)"
+  end
+
+  it "one default" do
+    handle('/one_default/my_default').should == "one_default (my_default)"
+  end
+
+  it "double underscore lookup" do
+    handle('/cat1/cat11').should == 'cat1: cat11'
+  end
+
+  it "double double underscore lookup" do
+    handle('/cat1/cat11/cat111').should == 'cat1: cat11: cat111'
+  end
+
+
+  it "jo/add should raise with 0 parameters" do
+    lambda{ handle('/jo/add') }.
+      should.raise(ArgumentError)
+  end
+
+  it "add should raise with 4 parameters" do
+    lambda{ handle('/jo/add/1/2/3/4') }.
+      should.raise(ArgumentError)
+  end
+
+  it "add should not raise with 1-3 parameters" do
+    handle('/jo/add/1').should == '1::'
+    handle('/jo/add/1/2').should == '1:2:'
+    handle('/jo/add/1/2/3').should == '1:2:3'
+  end
+
+  it 'params should have no content without params' do
+    handle('/ma').should == '""'
+  end
+
+  it 'should have a parameter via QUERY_PARAMS' do
+    handle('/ma?foo=bar').should == '"bar"'
+  end
+
+  it 'should handle valueless params' do
+    handle('/jo/keys?foo').should == '["foo"]'
+  end
+end