manveru-innate 2009.02.06

data/spec/innate/node/bar.html

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

data/spec/innate/node/foo.html.erb

@@ -0,0 +1 @@
+<% 10.times do |n| %><%= n %><% end %>

data/spec/innate/node/with_layout.erb

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

data/spec/innate/options.rb

@@ -0,0 +1,90 @@
+require 'lib/innate/core_compatibility/basic_object'
+require 'lib/innate/options/dsl'
+
+require 'bacon'
+
+Bacon.extend(Bacon::TestUnitOutput)
+Bacon.summary_on_exit
+
+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 '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 = [], []
+
+    @options.each{|k, v| keys << k; values << v }
+
+    keys.compact.sort_by{|k| k.to_s }.should == [:deep, :name, :port]
+    values.compact.size.should == 3
+  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=>4000/
+  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

data/spec/innate/request.rb

@@ -0,0 +1,73 @@
+require 'spec/helper'
+
+describe Innate::Request do
+  def request(env = {})
+    Innate::Request.new(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('PATH_INFO' => '/').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' 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')
+  end
+
+  should 'provide #accept_language' do
+    request(@env).accept_language.should == %w[en-us en de-at de]
+  end
+
+  should 'provide #http_variables' do
+    r = request(@env).http_variables
+    r.should.not.be.empty
+  end
+end

data/spec/innate/route.rb

@@ -0,0 +1,129 @@
+require 'spec/helper'
+
+class SpecRouter
+  include Innate::Node
+  map '/'
+  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
+end