rjspotter-innate 2009.06.29

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/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 :rack_test, :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 :rack_test, :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,79 @@
+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
+    require 'stringio'
+
+    query = {'a' => 'b', 'c' => 'd', 'e' => 'f'}
+    params = StringIO.new(Rack::Utils.build_query(query))
+    req = request('rack.request.form_hash' => params, 'rack.input' => params)
+
+    req.params.should == query
+    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